build/cycamore/growth_region.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/growth_region.h"
#ifndef CYCAMORE_SRC_GROWTH_REGION_H_
#define CYCAMORE_SRC_GROWTH_REGION_H_
 
#include <string>
#include <utility>
#include <vector>
 
#include "cyclus.h"
#include "cycamore_version.h"
 
// forward declarations
namespace cycamore {
class GrowthRegion;
}  // namespace cycamore
 
// forward includes
#include "growth_region_tests.h"
 
namespace cycamore {
 
typedef std::vector<
  std::pair<int, std::pair<std::string, std::string> > > Demand;
 
class GrowthRegion : public cyclus::Region,
  public cyclus::toolkit::Position {
  friend class GrowthRegionTests;
 public:
  GrowthRegion(cyclus::Context* ctx);
 
  virtual ~GrowthRegion();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
  virtual void InitFrom(cycamore::GrowthRegion* m) {
    cyclus::Region::InitFrom(m);
    int rawcycpp_shape_commodity_demand[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_commodity_demand = std::vector<int>(rawcycpp_shape_commodity_demand, rawcycpp_shape_commodity_demand + 8);
    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);
    commodity_demand = m->commodity_demand;
    latitude = m->latitude;
    longitude = m->longitude;
  };
#line 49 "/cycamore/src/growth_region.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b) {
    cyclus::Region::InitFrom(b);
    int rawcycpp_shape_commodity_demand[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_commodity_demand = std::vector<int>(rawcycpp_shape_commodity_demand, rawcycpp_shape_commodity_demand + 8);
    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);
    commodity_demand = qr.GetVal<std::map< std::string, std::vector< std::pair< int, std::pair< std::string, std::string > > > > >("commodity_demand");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
  };
#line 51 "/cycamore/src/growth_region.h"
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Region::InfileToDb(tree, di);
    int rawcycpp_shape_commodity_demand[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_commodity_demand = std::vector<int>(rawcycpp_shape_commodity_demand, rawcycpp_shape_commodity_demand + 8);
    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("growth", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("item");
      std::map< std::string, std::vector< std::pair< int, std::pair< std::string, std::string > > > > commodity_demand_val;
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string key;
        {
          std::string key_in = cyclus::Query<std::string>(sub, "item/commod", i1);
          key = key_in;
        }
        std::vector< std::pair< int, std::pair< std::string, std::string > > > val;
        {
          cyclus::InfileTree* bub = sub->SubTree("item/piecewise_function", i1);
          cyclus::InfileTree* sub = bub;
          int n2 = sub->NMatches("piece");
          std::vector< std::pair< int, std::pair< std::string, std::string > > > val_in;
          val_in.resize(n2);
          for (int i2 = 0; i2 < n2; ++i2) {
            std::pair< int, std::pair< std::string, std::string > > elem;
            {
              cyclus::InfileTree* bub = sub->SubTree("piece", i2);
              cyclus::InfileTree* sub = bub;
                int firsti2;
                {
                  int firsti2_in = cyclus::Query<int>(sub, "start", 0);
                  firsti2 = firsti2_in;
                }
                std::pair< std::string, std::string > secondi2;
                {
                  cyclus::InfileTree* bub = sub->SubTree("function", 0);
                  cyclus::InfileTree* sub = bub;
                    std::string first0;
                    {
                      std::string first0_in = cyclus::Query<std::string>(sub, "type", 0);
                      first0 = first0_in;
                    }
                    std::string second0;
                    {
                      std::string second0_in = cyclus::Query<std::string>(sub, "params", 0);
                      second0 = second0_in;
                    }
                  std::pair< std::string, std::string > secondi2_in(first0, second0);
                  secondi2 = secondi2_in;
                }
              std::pair< int, std::pair< std::string, std::string > > elem_in(firsti2, secondi2);
              elem = elem_in;
            }
            val_in[i2] = elem;
          }
          val = val_in;
        }
        commodity_demand_val[key] = val;
      }
      commodity_demand = commodity_demand_val;
    }
    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("commodity_demand", commodity_demand, &cycpp_shape_commodity_demand)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual cyclus::Agent* Clone() {
    cycamore::GrowthRegion* m = new cycamore::GrowthRegion(context());
    m->InitFrom(this);
    return m;
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"growth\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"item\">\n"
      "                <interleave>\n"
      "                    <element name=\"commod\">\n"
      "                        <data type=\"string\"/>\n"
      "                    </element>\n"
      "                    <element name=\"piecewise_function\">\n"
      "                        <oneOrMore>\n"
      "                            <element name=\"piece\">\n"
      "                                <interleave>\n"
      "                                    <element name=\"start\">\n"
      "                                        <data type=\"int\"/>\n"
      "                                    </element>\n"
      "                                    <element name=\"function\">\n"
      "                                        <interleave>\n"
      "                                            <element name=\"type\">\n"
      "                                                <data type=\"string\"/>\n"
      "                                            </element>\n"
      "                                            <element name=\"params\">\n"
      "                                                <data type=\"string\"/>\n"
      "                                            </element>\n"
      "                                        </interleave>\n"
      "                                    </element>\n"
      "                                </interleave>\n"
      "                            </element>\n"
      "                        </oneOrMore>\n"
      "                    </element>\n"
      "                </interleave>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\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::GrowthRegion\",\"entity\":\"region\""
      ",\"parents\":[\"cyclus::Region\",\"cyclus::toolkit::Pos"
      "ition\"],\"all_parents\":[\"cyclus::Agent\",\"cyclus::Id"
      "er\",\"cyclus::Region\",\"cyclus::StateWrangler\",\"cycl"
      "us::TimeListener\",\"cyclus::toolkit::Position\"],\"va"
      "rs\":{\"commodity_demand\":{\"alias\":[[\"growth\",\"item\""
      "],\"commod\",[\"piecewise_function\",[\"piece\",\"start\","
      "[\"function\",\"type\",\"params\"]]]],\"uitype\":[\"oneormo"
      "re\",\"string\",[\"oneormore\",[\"pair\",\"int\",[\"pair\",\"s"
      "tring\",\"string\"]]]],\"uilabel\":[[\"Growth Demand Cur"
      "ves\",\"\"],\"\",[\"\",[\"\",\"\",[\"\",\"\",\"\"]]]],\"doc\":\"Namepl"
      "ate capacity demand functions.\\n\\nEach demand type"
      " must be for a commodity for which capacity can be"
      " built (e.g., 'power' from cycamore::Reactors). "
      "Any archetype that implements the "
      "cyclus::toolkit::CommodityProducer interface can "
      "interact with the GrowthRegion in the "
      "manner.\\n\\nDemand functions are defined as "
      "piecewise functions. Each piece must be provided a"
      " starting time and function description. Each "
      "function description is comprised of a function "
      "type and associated parameters. \\n\\n  * Start "
      "times are inclusive. For a start time :math:`t_0`,"
      " the demand function is evaluated on :math:`[t_0, "
      "\\\\infty)`.\\n\\n  * Supported function types are "
      "based on the "
      "`cyclus::toolkit::BasicFunctionFactory types <http"
      "://fuelcycle.org/cyclus/api/classcyclus_1_1toolkit"
      "_1_1BasicFunctionFactory.html#a2f3806305d99a745ab5"
      "7c300e54a603d>`_. \\n\\n  * The type name is the "
      "lower-case name of the function (e.g., 'linear', "
      "'exponential', etc.).\\n\\n  * The parameters "
      "associated with each function type can be found on"
      " their respective documentation pages.\",\"type\":[\"s"
      "td::map\",\"std::string\",[\"std::vector\",[\"std::pair\""
      ",\"int\",[\"std::pair\",\"std::string\",\"std::string\"]]]"
      "],\"index\":0,\"shape\":[-1,-1,-1,-1,-1,-1,-1,-"
      "1],\"tooltip\":[[\"commodity_demand\",\"\"],\"\",[\"\",[\"\",\""
      "\",[\"\",\"\",\"\"]]]]},\"growth\":\"commodity_demand\",\"lati"
      "tude\":{\"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\":2,\"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\":3,\"shape\":[-"
      "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"do"
      "c\":\"A region that governs a scenario in which "
      "there is growth in demand for a commodity. \"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::GrowthRegion.");
    }
    return root;
  };
 
  virtual void InitInv(cyclus::Inventories& inv) {
  };
 
  virtual cyclus::Inventories SnapshotInv() {
    cyclus::Inventories invs;
    return invs;
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("commodity_demand", commodity_demand, &cycpp_shape_commodity_demand)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  #pragma cyclus note {"doc": "A region that governs a scenario in which "                               "there is growth in demand for a commodity. "}
#line 54 "/cycamore/src/growth_region.h"
 
  virtual void Tick();
 
  virtual void EnterNotify();
 
  virtual void DecomNotify(Agent* m);
 
  inline cyclus::toolkit::SupplyDemandManager* sdmanager() {
    return &sdmanager_;
  }
 
 protected:
  #pragma cyclus var {     "alias": ["growth", "commod",               ["piecewise_function",                                                   ["piece", "start", ["function", "type", "params"]]]],        "uitype": ["oneormore", "string",                ["oneormore",                 ["pair", "int", ["pair", "string", "string"]]]],          "uilabel": "Growth Demand Curves",     "doc": "Nameplate capacity demand functions."     "\n\n"                                           "Each demand type must be for a commodity for which capacity can be built "    "(e.g., 'power' from cycamore::Reactors). Any archetype that implements the "    "cyclus::toolkit::CommodityProducer interface can interact with the "    "GrowthRegion in the manner."                                           "\n\n"                                           "Demand functions are defined as piecewise functions. Each piece must "    "be provided a starting time and function description. Each function "    "description is comprised of a function type and associated parameters. "    "\n\n"                                           "  * Start times are inclusive. For a start time :math:`t_0`, the demand "    "function is evaluated on :math:`[t_0, \infty)`."                         "\n\n"                                           "  * Supported function types are based on the "    "`cyclus::toolkit::BasicFunctionFactory "    "types <http://fuelcycle.org/cyclus/api/classcyclus_1_1toolkit_1_1BasicFunctionFactory.html#a2f3806305d99a745ab57c300e54a603d>`_. "     "\n\n"                                           "  * The type name is the lower-case name of the function (e.g., "     "'linear', 'exponential', etc.)."     "\n\n"                                           "  * The parameters associated with each function type can be found on their "     "respective documentation pages.",                                    }
  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string> > > > commodity_demand;
  std::vector<int> cycpp_shape_commodity_demand;
 // must match Demand typedef
#line 106 "/cycamore/src/growth_region.h"
 
#if CYCLUS_HAS_COIN
  cyclus::toolkit::BuildingManager buildmanager_;
#endif
 
  cyclus::toolkit::SupplyDemandManager sdmanager_;
 
  void Register_(cyclus::Agent* agent);
 
  void Unregister_(cyclus::Agent* agent);
 
  void AddCommodityDemand_(std::string commod, Demand& demand);
 
  void OrderBuilds(cyclus::toolkit::Commodity& commodity, double unmetdemand);
 
  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 138 "/cycamore/src/growth_region.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 139 "/cycamore/src/growth_region.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 146 "/cycamore/src/growth_region.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 147 "/cycamore/src/growth_region.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_GROWTH_REGION_H_