build/cycamore/sink.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/sink.h"
#ifndef CYCAMORE_SRC_SINK_H_
#define CYCAMORE_SRC_SINK_H_
 
#include <algorithm>
#include <string>
#include <utility>
#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 Sink
  : public cyclus::Facility,
    public cyclus::toolkit::Position  {
 public:
  Sink(cyclus::Context* ctx);
 
  virtual ~Sink();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
  #pragma cyclus note {     "doc":     " A sink facility that accepts materials and products with a fixed\n"    " throughput (per time step) capacity and a lifetime capacity defined by\n"    " a total inventory size. The inventory size and throughput capacity\n"    " both default to infinite. If a recipe is provided, it will request\n"    " material with that recipe. Requests are made for any number of\n"    " specified commodities.\n"     }
#line 42 "/cycamore/src/sink.h"
 
  virtual void InitFrom(cycamore::Sink* m);
 
  virtual void InitFrom(cyclus::QueryableBackend* b);
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di);
 
  virtual cyclus::Agent* Clone();
 
  virtual std::string schema();
 
  virtual Json::Value annotations();
 
  virtual void InitInv(cyclus::Inventories& inv);
 
  virtual cyclus::Inventories SnapshotInv();
 
  virtual void Snapshot(cyclus::DbInit di);
#line 44 "/cycamore/src/sink.h"
 
  virtual std::string str();
 
  virtual void EnterNotify();
 
  virtual void Tick();
 
  virtual void Tock();
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
      GetMatlRequests();
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Product>::Ptr>
      GetGenRsrcRequests();
 
  virtual void AcceptMatlTrades(
      const std::vector< std::pair<cyclus::Trade<cyclus::Material>,
      cyclus::Material::Ptr> >& responses);
 
  virtual void AcceptGenRsrcTrades(
      const std::vector< std::pair<cyclus::Trade<cyclus::Product>,
      cyclus::Product::Ptr> >& responses);
 
  virtual void SetRequestAmt();
 
  virtual void SetNextBuyTime();
 
  inline void AddCommodity(std::string name) { in_commods.push_back(name); }
 
  inline void SetMaxInventorySize(double size) {
    max_inv_size = size;
    inventory.capacity(size);
  }
 
  inline double MaxInventorySize() const { return inventory.capacity(); }
 
  inline double InventorySize() const { return inventory.quantity(); }
 
  inline double SpaceAvailable() const {
    return std::min(capacity, std::max(0.0, inventory.space()));
  }
 
  inline void Capacity(double cap) { capacity = cap; }
 
  inline double Capacity() const { return capacity; }
 
  inline const std::vector<std::string>&
      input_commodities() const { return in_commods; }
 
  inline const std::vector<double>&
      input_commodity_preferences() const { return in_commod_prefs; }
 
 private:
  double requestAmt;
  int nextBuyTime;
  #pragma cyclus var {"tooltip": "input commodities",                       "doc": "commodities that the sink facility accepts",                       "uilabel": "List of Input Commodities",                       "uitype": ["oneormore", "incommodity"]}
#line 125 "/cycamore/src/sink.h"
  std::vector<std::string> in_commods;
  std::vector<int> cycpp_shape_in_commods;
#line 126 "/cycamore/src/sink.h"
 
 
  #pragma cyclus var {"default": [],                      "doc":"preferences for each of the given commodities, in the same order."                      "Defauts to 1 if unspecified",                      "uilabel":"In Commody Preferences",                       "range": [None, [CY_NEAR_ZERO, CY_LARGE_DOUBLE]],                       "uitype":["oneormore", "range"]}
#line 133 "/cycamore/src/sink.h"
  std::vector<double> in_commod_prefs;
  std::vector<int> cycpp_shape_in_commod_prefs;
#line 134 "/cycamore/src/sink.h"
 
 
  #pragma cyclus var {"default": "",                       "tooltip": "requested composition",                       "doc": "name of recipe to use for material requests, "                              "where the default (empty string) is to accept "                              "everything",                       "uilabel": "Input Recipe",                       "uitype": "inrecipe"}
#line 142 "/cycamore/src/sink.h"
  std::string recipe_name;
  std::vector<int> cycpp_shape_recipe_name;
 
#line 143 "/cycamore/src/sink.h"
 
  #pragma cyclus var {"default": CY_LARGE_DOUBLE,                       "tooltip": "sink maximum inventory size",                       "uilabel": "Maximum Inventory",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "total maximum inventory size of sink facility"}
#line 151 "/cycamore/src/sink.h"
  double max_inv_size;
  std::vector<int> cycpp_shape_max_inv_size;
 
#line 152 "/cycamore/src/sink.h"
 
  #pragma cyclus var {"default": CY_LARGE_DOUBLE,                       "tooltip": "sink capacity",                       "uilabel": "Maximum Throughput",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "capacity the sink facility can "                              "accept at each time step"}
#line 161 "/cycamore/src/sink.h"
  double capacity;
  std::vector<int> cycpp_shape_capacity;
 
#line 162 "/cycamore/src/sink.h"
 
  #pragma cyclus var {'capacity': 'max_inv_size'}
  cyclus::toolkit::ResBuf<cyclus::Resource> inventory;
  std::vector<int> cycpp_shape_inventory;
 
#line 166 "/cycamore/src/sink.h"
 
  #pragma cyclus var {"default": "None",                       "tooltip": "type of random behavior when setting the "                       "size of the request",                       "uitype": "combobox",                       "uilabel": "Random Size",                       "categorical": ["None", "UniformReal", "UniformInt", "NormalReal", "NormalInt"],                       "doc": "type of random behavior to use. Default None, "                       "other options are 'UniformReal', 'UniformInt', "                       "'NormalReal', and 'NormalInt'"}
#line 177 "/cycamore/src/sink.h"
  std::string random_size_type;
  std::vector<int> cycpp_shape_random_size_type;
 
#line 178 "/cycamore/src/sink.h"
 
  // random size mean (as a fraction of available space)
  #pragma cyclus var {"default": 1.0,                       "tooltip": "fraction of available space to determine the mean",                       "uilabel": "Random Size Mean",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "When a normal distribution is used to determine the "                              "size of the request, this is the fraction of available "                              "space to use as the mean. Default 1.0. Note "                              "that values significantly above 1 without a "                              "correspondingly large std dev may result in "                              "inefficient use of the random number generator."}
#line 191 "/cycamore/src/sink.h"
  double random_size_mean;
  std::vector<int> cycpp_shape_random_size_mean;
 
#line 192 "/cycamore/src/sink.h"
 
  // random size std dev (as a fraction of available space)
  #pragma cyclus var {"default": 0.1,                       "tooltip": "fraction of available space to determine the std dev",                       "uilabel": "Random Size Std Dev",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "When a normal distribution is used to determine the "                              "size of the request, this is the fraction of available "                              "space to use as the standard deviation. Default 0.1"}
#line 202 "/cycamore/src/sink.h"
  double random_size_stddev;
  std::vector<int> cycpp_shape_random_size_stddev;
 
#line 203 "/cycamore/src/sink.h"
 
  // random status (frequencing/timing of request)
  #pragma cyclus var {"default": "None",                       "tooltip": "type of random behavior when setting the "                       "timing of the request",                       "uitype": "combobox",                       "uilabel": "Random Timing",                       "categorical": ["None", "UniformInt", "NormalInt"],                       "doc": "type of random behavior to use. Default None, "                       "other options are, 'UniformInt', and 'NormalInt'. "                       "When using 'UniformInt', also set "                      "'random_frequency_min' and 'random_frequency_max'. "                       "For 'NormalInt', set 'random_frequency_mean' and "                       "'random_fequency_stddev', min and max values are "                       "optional. "}
#line 218 "/cycamore/src/sink.h"
  std::string random_frequency_type;
  std::vector<int> cycpp_shape_random_frequency_type;
 
#line 219 "/cycamore/src/sink.h"
 
  // random frequency mean 
  #pragma cyclus var {"default": 1,                       "tooltip": "mean of the random frequency",                       "uilabel": "Random Frequency Mean",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "When a normal distribution is used to determine the "                              "frequency of the request, this is the mean. Default 1"}
#line 228 "/cycamore/src/sink.h"
  double random_frequency_mean;
  std::vector<int> cycpp_shape_random_frequency_mean;
 
#line 229 "/cycamore/src/sink.h"
 
  // random frequency std dev
  #pragma cyclus var {"default": 1,                       "tooltip": "std dev of the random frequency",                       "uilabel": "Random Frequency Std Dev",                       "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "doc": "When a normal distribution is used to determine the "                              "frequency of the request, this is the standard deviation. Default 1"}
#line 238 "/cycamore/src/sink.h"
  double random_frequency_stddev;
  std::vector<int> cycpp_shape_random_frequency_stddev;
 
#line 239 "/cycamore/src/sink.h"
 
  // random frequency lower bound
  #pragma cyclus var {"default": 1,                       "tooltip": "lower bound of the random frequency",                       "uilabel": "Random Frequency Lower Bound",                       "uitype": "range",                       "range": [1, CY_LARGE_INT],                       "doc": "When a random distribution is used to determine the "                              "frequency of the request, this is the lower bound. Default 1"}
#line 248 "/cycamore/src/sink.h"
  int random_frequency_min;
  std::vector<int> cycpp_shape_random_frequency_min;
 
#line 249 "/cycamore/src/sink.h"
 
  // random frequency upper bound
  #pragma cyclus var {"default": CY_LARGE_INT,                       "tooltip": "upper bound of the random frequency",                       "uilabel": "Random Frequency Upper Bound",                       "uitype": "range",                       "range": [1, CY_LARGE_INT],                       "doc": "When a random distribution is used to determine the "                              f"frequency of the request, this is the upper bound. Default {CY_LARGE_INT} (CY_LARGE_INT)"}
#line 258 "/cycamore/src/sink.h"
  int random_frequency_max;
  std::vector<int> cycpp_shape_random_frequency_max;
#line 259 "/cycamore/src/sink.h"
 
 
  #pragma cyclus var {     "default": True,     "tooltip": "Whether to persist packaging in the sink.",     "doc": "Boolean value about whether to keep packaging. If true, "            "packaging will not be stripped upon acceptance into the "            "sink. If false, package type will be stripped immediately "            "upon acceptance. Has no effect if the incoming material is not "            "packaged.",     "uilabel": "Keep Packaging",     "uitype": "bool"}
#line 270 "/cycamore/src/sink.h"
  bool keep_packaging;
  std::vector<int> cycpp_shape_keep_packaging;
#line 271 "/cycamore/src/sink.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 278 "/cycamore/src/sink.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 279 "/cycamore/src/sink.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 286 "/cycamore/src/sink.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 287 "/cycamore/src/sink.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
 
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_SINK_H_