build/cycamore/deploy_inst.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/deploy_inst.h"
#ifndef CYCAMORE_SRC_DEPLOY_INST_H_
#define CYCAMORE_SRC_DEPLOY_INST_H_
 
#include <utility>
#include <set>
#include <map>
 
#include "cyclus.h"
#include "cycamore_version.h"
 
namespace cycamore {
 
typedef std::map<int, std::vector<std::string> > BuildSched;
 
// Builds and manages agents (facilities) according to a manually specified
// deployment schedule. Deployed agents are automatically decommissioned at
// the end of their lifetime.  The user specifies a list of prototypes for
// each and corresponding build times, number to build, and (optionally)
// lifetimes.  The same prototype can be specified multiple times with any
// combination of the same or different build times, build number, and
// lifetimes.
class DeployInst : 
  public cyclus::Institution, 
  public cyclus::toolkit::CommodityProducerManager,
  public cyclus::toolkit::Position {
  #pragma cyclus note {     "doc":       "Builds and manages agents (facilities) according to a manually"       " specified deployment schedule. Deployed agents are automatically"       " decommissioned at the end of their lifetime.  Deployed and"       " decommissioned agents are registered and unregistered with a"       " region. The user specifies a list of prototypes for"       " each and corresponding build times, number to build, and (optionally)"       " lifetimes.  The same prototype can be specified multiple times with"       " any combination of the same or different build times, build number,"       " and lifetimes. "   }
#line 38 "/cycamore/src/deploy_inst.h"
 public:
  DeployInst(cyclus::Context* ctx);
 
  virtual ~DeployInst();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
  virtual void InitFrom(cycamore::DeployInst* m) {
    cyclus::Institution::InitFrom(m);
    int rawcycpp_shape_prototypes[2] = {-1, -1};
    cycpp_shape_prototypes = std::vector<int>(rawcycpp_shape_prototypes, rawcycpp_shape_prototypes + 2);
    int rawcycpp_shape_build_times[2] = {-1, -1};
    cycpp_shape_build_times = std::vector<int>(rawcycpp_shape_build_times, rawcycpp_shape_build_times + 2);
    int rawcycpp_shape_n_build[2] = {-1, -1};
    cycpp_shape_n_build = std::vector<int>(rawcycpp_shape_n_build, rawcycpp_shape_n_build + 2);
    int rawcycpp_shape_lifetimes[2] = {-1, -1};
    cycpp_shape_lifetimes = std::vector<int>(rawcycpp_shape_lifetimes, rawcycpp_shape_lifetimes + 2);
    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);
    prototypes = m->prototypes;
    build_times = m->build_times;
    n_build = m->n_build;
    lifetimes = m->lifetimes;
    latitude = m->latitude;
    longitude = m->longitude;
  };
#line 44 "/cycamore/src/deploy_inst.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b) {
    cyclus::Institution::InitFrom(b);
    int rawcycpp_shape_prototypes[2] = {-1, -1};
    cycpp_shape_prototypes = std::vector<int>(rawcycpp_shape_prototypes, rawcycpp_shape_prototypes + 2);
    int rawcycpp_shape_build_times[2] = {-1, -1};
    cycpp_shape_build_times = std::vector<int>(rawcycpp_shape_build_times, rawcycpp_shape_build_times + 2);
    int rawcycpp_shape_n_build[2] = {-1, -1};
    cycpp_shape_n_build = std::vector<int>(rawcycpp_shape_n_build, rawcycpp_shape_n_build + 2);
    int rawcycpp_shape_lifetimes[2] = {-1, -1};
    cycpp_shape_lifetimes = std::vector<int>(rawcycpp_shape_lifetimes, rawcycpp_shape_lifetimes + 2);
    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);
    prototypes = qr.GetVal<std::vector< std::string > >("prototypes");
    build_times = qr.GetVal<std::vector< int > >("build_times");
    n_build = qr.GetVal<std::vector< int > >("n_build");
    lifetimes = qr.GetVal<std::vector< int > >("lifetimes");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
  };
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Institution::InfileToDb(tree, di);
    int rawcycpp_shape_prototypes[2] = {-1, -1};
    cycpp_shape_prototypes = std::vector<int>(rawcycpp_shape_prototypes, rawcycpp_shape_prototypes + 2);
    int rawcycpp_shape_build_times[2] = {-1, -1};
    cycpp_shape_build_times = std::vector<int>(rawcycpp_shape_build_times, rawcycpp_shape_build_times + 2);
    int rawcycpp_shape_n_build[2] = {-1, -1};
    cycpp_shape_n_build = std::vector<int>(rawcycpp_shape_n_build, rawcycpp_shape_n_build + 2);
    int rawcycpp_shape_lifetimes[2] = {-1, -1};
    cycpp_shape_lifetimes = std::vector<int>(rawcycpp_shape_lifetimes, rawcycpp_shape_lifetimes + 2);
    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("prototypes", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > prototypes_val;
      prototypes_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;
        }
        prototypes_val[i1] = elem;
      }
      prototypes = prototypes_val;
    }
    {
      cyclus::InfileTree* bub = sub->SubTree("build_times", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< int > build_times_val;
      build_times_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        int elem;
        {
          int elem_in = cyclus::Query<int>(sub, "val", i1);
          elem = elem_in;
        }
        build_times_val[i1] = elem;
      }
      build_times = build_times_val;
    }
    {
      cyclus::InfileTree* bub = sub->SubTree("n_build", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< int > n_build_val;
      n_build_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        int elem;
        {
          int elem_in = cyclus::Query<int>(sub, "val", i1);
          elem = elem_in;
        }
        n_build_val[i1] = elem;
      }
      n_build = n_build_val;
    }
    if (sub->NMatches("lifetimes") > 0) {
      {
        cyclus::InfileTree* bub = sub->SubTree("lifetimes", 0);
        cyclus::InfileTree* sub = bub;
        int n1 = sub->NMatches("val");
        std::vector< int > lifetimes_val;
        lifetimes_val.resize(n1);
        for (int i1 = 0; i1 < n1; ++i1) {
          int elem;
          {
            int elem_in = cyclus::Query<int>(sub, "val", i1);
            elem = elem_in;
          }
          lifetimes_val[i1] = elem;
        }
        lifetimes = lifetimes_val;
      }
    } else {
      std::vector< int > lifetimes_tmp;
      lifetimes_tmp.resize(0);
      {
      }
      lifetimes = lifetimes_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("prototypes", prototypes, &cycpp_shape_prototypes)
    ->AddVal("build_times", build_times, &cycpp_shape_build_times)
    ->AddVal("n_build", n_build, &cycpp_shape_n_build)
    ->AddVal("lifetimes", lifetimes, &cycpp_shape_lifetimes)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual cyclus::Agent* Clone() {
    cycamore::DeployInst* m = new cycamore::DeployInst(context());
    m->InitFrom(this);
    return m;
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"prototypes\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"string\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <element name=\"build_times\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"int\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <element name=\"n_build\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"int\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"lifetimes\">\n"
      "            <oneOrMore>\n"
      "                <element name=\"val\">\n"
      "                    <data type=\"int\"/>\n"
      "                </element>\n"
      "            </oneOrMore>\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::DeployInst\",\"entity\":\"instituti"
      "on\",\"parents\":[\"cyclus::Institution\",\"cyclus::tool"
      "kit::CommodityProducerManager\",\"cyclus::toolkit::P"
      "osition\"],\"all_parents\":[\"cyclus::Agent\",\"cyclus::"
      "Ider\",\"cyclus::Institution\",\"cyclus::StateWrangler"
      "\",\"cyclus::TimeListener\",\"cyclus::toolkit::AgentMa"
      "naged\",\"cyclus::toolkit::CommodityProducerManager\""
      ",\"cyclus::toolkit::Position\"],\"vars\":{\"prototypes\""
      ":{\"doc\":\"Ordered list of prototypes to build.\",\"ui"
      "type\":[\"oneormore\",\"prototype\"],\"uilabel\":[\"Protot"
      "ypes to deploy\",\"\"],\"type\":[\"std::vector\",\"std::st"
      "ring\"],\"index\":0,\"shape\":[-1,-"
      "1],\"alias\":[\"prototypes\",\"val\"],\"tooltip\":[\"protot"
      "ypes\",\"\"]},\"build_times\":{\"doc\":\"Time step on "
      "which to deploy agents given in prototype list "
      "(same order).\",\"uilabel\":[\"Deployment times\",\"\"],\""
      "type\":[\"std::vector\",\"int\"],\"index\":1,\"shape\":[-"
      "1,-"
      "1],\"alias\":[\"build_times\",\"val\"],\"tooltip\":[\"build"
      "_times\",\"\"]},\"n_build\":{\"doc\":\"Number of each "
      "prototype given in prototype list that should be "
      "deployed (same order).\",\"uilabel\":[\"Number to depl"
      "oy\",\"\"],\"type\":[\"std::vector\",\"int\"],\"index\":2,\"sh"
      "ape\":[-1,-"
      "1],\"alias\":[\"n_build\",\"val\"],\"tooltip\":[\"n_build\","
      "\"\"]},\"lifetimes\":{\"doc\":\"Lifetimes for each "
      "prototype in prototype list (same order). These "
      "lifetimes override the lifetimes in the original "
      "prototype definition. If unspecified, lifetimes "
      "from the original prototype definitions are used. "
      "Although a new prototype is created in the "
      "Prototypes table for each lifetime with the suffix"
      " '_life_[lifetime]', all deployed agents "
      "themselves will have the same original prototype "
      "name (and so will the Agents tables).\",\"default\":["
      "],\"uilabel\":[\"Lifetimes\",\"\"],\"type\":[\"std::vector\""
      ",\"int\"],\"index\":3,\"shape\":[-1,-"
      "1],\"alias\":[\"lifetimes\",\"val\"],\"tooltip\":[\"lifetim"
      "es\",\"\"]},\"latitude\":{\"default\":0.0,\"uilabel\":\"Geog"
      "raphical 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\":4,\"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\":5,\"shape\":[-"
      "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"do"
      "c\":\"Builds and manages agents (facilities) "
      "according to a manually specified deployment "
      "schedule. Deployed agents are automatically "
      "decommissioned at the end of their lifetime.  "
      "Deployed and decommissioned agents are registered "
      "and unregistered with a region. The user specifies"
      " a list of prototypes for each and corresponding "
      "build times, number to build, and (optionally) "
      "lifetimes.  The same prototype can be specified "
      "multiple times with any combination of the same or"
      " different build times, build number, and "
      "lifetimes. \"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::DeployInst.");
    }
    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("prototypes", prototypes, &cycpp_shape_prototypes)
    ->AddVal("build_times", build_times, &cycpp_shape_build_times)
    ->AddVal("n_build", n_build, &cycpp_shape_n_build)
    ->AddVal("lifetimes", lifetimes, &cycpp_shape_lifetimes)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
#line 46 "/cycamore/src/deploy_inst.h"
 
  virtual void Build(cyclus::Agent* parent);
 
  virtual void EnterNotify();
 
  virtual void BuildNotify(Agent* m);
  virtual void DecomNotify(Agent* m);
  void WriteProducerInformation(cyclus::toolkit::CommodityProducer*
                                producer);
 
  private:
  void Register_(cyclus::Agent* agent);
 
  void Unregister_(cyclus::Agent* agent);
 
 protected:
  #pragma cyclus var {     "doc": "Ordered list of prototypes to build.",     "uitype": ("oneormore", "prototype"),     "uilabel": "Prototypes to deploy",   }
#line 71 "/cycamore/src/deploy_inst.h"
  std::vector<std::string> prototypes;
  std::vector<int> cycpp_shape_prototypes;
#line 86 "/cycamore/src/deploy_inst.h"
 
 
  #pragma cyclus var {     "doc": "Time step on which to deploy agents given in prototype list "            "(same order).",                                                "uilabel": "Deployment times",                                        }
  std::vector<int> build_times;
  std::vector<int> cycpp_shape_build_times;
 
 
  #pragma cyclus var {     "doc": "Number of each prototype given in prototype list that should be "            "deployed (same order).",     "uilabel": "Number to deploy",   }
  std::vector<int> n_build;
  std::vector<int> cycpp_shape_n_build;
 
 
 
  #pragma cyclus var {                                                      "doc": "Lifetimes for each prototype in prototype list (same order)."            " These lifetimes override the lifetimes in the original prototype"            " definition."            " If unspecified, lifetimes from the original prototype definitions"           " are used."            " Although a new prototype is created in the Prototypes table for"            " each lifetime with the suffix '_life_[lifetime]',"            " all deployed agents themselves will have the same original"            " prototype name (and so will the Agents tables).",     "default": [],     "uilabel": "Lifetimes"   }
#line 101 "/cycamore/src/deploy_inst.h"
  std::vector<int> lifetimes;
  std::vector<int> cycpp_shape_lifetimes;
 
#line 102 "/cycamore/src/deploy_inst.h"
 
 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 110 "/cycamore/src/deploy_inst.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 111 "/cycamore/src/deploy_inst.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 118 "/cycamore/src/deploy_inst.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 119 "/cycamore/src/deploy_inst.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
 
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_DEPLOY_INST_H_