build/cycamore/storage.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/storage.h"
#ifndef CYCLUS_STORAGES_STORAGE_H_
#define CYCLUS_STORAGES_STORAGE_H_
 
#include <string>
#include <list>
#include <vector>
 
#include "cyclus.h"
#include "cycamore_version.h"
 
#include "boost/shared_ptr.hpp"
 
#pragma cyclus exec from cyclus.system import CY_LARGE_DOUBLE, CY_LARGE_INT, CY_NEAR_ZERO
 
namespace cycamore {
class Storage
  : public cyclus::Facility,
    public cyclus::toolkit::CommodityProducer,
    public cyclus::toolkit::Position {
 public:
  Storage(cyclus::Context* ctx);
  virtual void InitFrom(cycamore::Storage* m);
#line 108 "/cycamore/src/storage.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b);
#line 110 "/cycamore/src/storage.h"
 
  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);
 
  #pragma cyclus note {"doc": "Storage is a simple facility which accepts any number of commodities "                               "and holds them for a user specified amount of time. The commodities accepted "                              "are chosen based on the specified preferences list. Once the desired amount of material "                              "has entered the facility it is passed into a 'processing' buffer where it is held until "                              "the residence time has passed. The material is then passed into a 'ready' buffer where it is "                              "queued for removal. Currently, all input commodities are lumped into a single output commodity. "                              "Storage also has the functionality to handle materials in discrete or continuous batches. Discrete "                              "mode, which is the default, does not split or combine material batches. Continuous mode, however, "                              "divides material batches if necessary in order to push materials through the facility as quickly "                              "as possible."}
#line 121 "/cycamore/src/storage.h"
 
  virtual std::string str();
 
  // --- Facility Members ---
 
  // --- Agent Members ---
  virtual void EnterNotify();
 
  virtual void Tick();
 
  virtual void Tock();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
 protected:
  void InitBuyPolicyParameters();
  void AddMat_(cyclus::Material::Ptr mat);
 
  void BeginProcessing_();
 
  void ProcessMat_(double cap);
 
  void ReadyMatl_(int time);/* --- Storage Members --- */
#line 159 "/cycamore/src/storage.h"
 
  inline double current_capacity() {
    return (inventory_tracker.space()); }
 
  inline double capacity() { return inventory_tracker.capacity(); }
 
  int ready_time(){ return context()->time() - residence_time; }/* --- Module Members --- */
#line 169 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"input commodity",                      "doc":"commodities accepted by this facility",                      "uilabel":"Input Commodities",                      "uitype":["oneormore","incommodity"]}
  std::vector<std::string> in_commods;
  std::vector<int> cycpp_shape_in_commods;
#line 171 "/cycamore/src/storage.h"
 
#line 177 "/cycamore/src/storage.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 184 "/cycamore/src/storage.h"
  std::vector<double> in_commod_prefs;
  std::vector<int> cycpp_shape_in_commod_prefs;
#line 185 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"tooltip":"output commodity",                      "doc":"commodity produced by this facility. Multiple commodity tracking is"                      " currently not supported, one output commodity catches all input commodities.",                      "uilabel":"Output Commodities",                      "uitype":["oneormore","outcommodity"]}
#line 191 "/cycamore/src/storage.h"
  std::vector<std::string> out_commods;
  std::vector<int> cycpp_shape_out_commods;
#line 192 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default":"",                      "tooltip":"input recipe",                      "doc":"recipe accepted by this facility, if unspecified a dummy recipe is used",                      "uilabel":"Input Recipe",                      "uitype":"inrecipe"}
#line 198 "/cycamore/src/storage.h"
  std::string in_recipe;
  std::vector<int> cycpp_shape_in_recipe;
#line 199 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip":"residence time (timesteps)",                      "doc":"the minimum holding time for a received commodity (timesteps).",                      "units":"time steps",                      "uilabel":"Residence Time",                       "uitype": "range",                       "range": [0, 12000]}
#line 207 "/cycamore/src/storage.h"
  int residence_time;
  std::vector<int> cycpp_shape_residence_time;
#line 208 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip":"sell quantity (kg)",                      "doc":"material will be sold in integer multiples of this quantity. If"                      " the buffer contains less than the sell quantity, no material will be"                      " offered",                       "uilabel":"Sell Quantity",                      "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "units": "kg"}
#line 218 "/cycamore/src/storage.h"
  double sell_quantity;
  std::vector<int> cycpp_shape_sell_quantity;
#line 219 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": CY_LARGE_DOUBLE,                     "tooltip":"throughput per timestep (kg)",                     "doc":"the max amount that can be moved through the facility per timestep (kg)",                     "uilabel":"Throughput",                     "uitype": "range",                      "range": [0.0, CY_LARGE_DOUBLE],                      "units":"kg"}
#line 227 "/cycamore/src/storage.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
#line 228 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": CY_LARGE_DOUBLE,                      "tooltip":"maximum inventory size (kg)",                      "doc":"the maximum amount of material that can be in all storage buffer stages",                      "uilabel":"Maximum Inventory Size",                      "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "units":"kg"}
#line 236 "/cycamore/src/storage.h"
  double max_inv_size;
  std::vector<int> cycpp_shape_max_inv_size;
#line 237 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": False,                      "tooltip":"Bool to determine how Storage handles batches",                      "doc":"Determines if Storage will divide resource objects. Only controls material "                            "handling within this facility, has no effect on DRE material handling. "                            "If true, batches are handled as discrete quanta, neither split nor combined. "                            "Otherwise, batches may be divided during processing. Default to false (continuous))",                      "uilabel":"Batch Handling"}
#line 245 "/cycamore/src/storage.h"
  bool discrete_handling;
  std::vector<int> cycpp_shape_discrete_handling;
#line 246 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": "Fixed",                      "tooltip": "Type of active buying frequency",                      "doc": "Options: Fixed, Uniform, Normal, Binomial, FixedWithDisruption. "                      "Fixed requires active_buying_val. Uniform "                      "requires active_buying_min and active_buying_max.  Normal "                      "requires active_buying_mean and active_buying_std, with optional "                      "active_buying_min and active_buying_max. Binomial requires active_buying_end_probability."                      "FixedWithDisruption has a probability that any given cycle will have a disrupted, "                      "active length.  Once per cycle, a Bernoulli distribution (Binomial dist "                      "with N=1) will be sampled to determine if typical or disrupted cycle. If typical, "                      "active_buying_val is cycle length. If disrupted, active_buying_disruption.",                      "uitype": "combobox",                      "categorical": ["Fixed", "Uniform", "Normal", "Binomial", "FixedWithDisruption"],                      "uilabel": "Active Buying Frequency Type"}
#line 261 "/cycamore/src/storage.h"
  std::string active_buying_frequency_type;
  std::vector<int> cycpp_shape_active_buying_frequency_type;
#line 262 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Fixed active buying frequency",                      "doc": "The length in time steps of the active buying period. Required for fixed "                      "active_buying_frequency_type. Must be greater than or equal to 1 (i.e., agent "                      "cannot always be dormant)",                      "uitype": "range",                       "range": [1, CY_LARGE_INT],                       "uilabel": "Active Buying Frequency Value"}
#line 271 "/cycamore/src/storage.h"
  int active_buying_val;
  std::vector<int> cycpp_shape_active_buying_val;
#line 272 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Active buying distribution minimum",                      "doc": "The minimum length in time steps of the active buying period. Required for "                      "Uniform and optional for Normal active_buying_frequency_type. Must be greater than "                      "or equal to 1 ",                      "uitype": "range",                       "range": [1, CY_LARGE_INT],                       "uilabel": "Active Buying Frequency Minimum"}
#line 281 "/cycamore/src/storage.h"
  int active_buying_min;
  std::vector<int> cycpp_shape_active_buying_min;
#line 282 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Active buying distribution maximum",                      "doc": "The maximum length in time steps of the active buying period. Required for "                      "Uniform active_buying_frequency_type, optional for Normal. Must be greater than or equal to active_buying_min ",                      "uitype": "range",                       "range": [1, CY_LARGE_INT],                       "uilabel": "Active Buying Frequency Maximum"}
#line 290 "/cycamore/src/storage.h"
  int active_buying_max;
  std::vector<int> cycpp_shape_active_buying_max;
#line 291 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Active buying distribution mean",                      "doc": "The mean length in time steps of the active buying period. Required for "                      "Normal active_buying_frequency_type. Must be greater than or equal to 1 ",                      "uitype": "range",                       "range": [1.0, CY_LARGE_DOUBLE],                       "uilabel": "Active Buying Frequency Mean"}
#line 299 "/cycamore/src/storage.h"
  double active_buying_mean;
  std::vector<int> cycpp_shape_active_buying_mean;
#line 300 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Active buying distribution standard deviation",                      "doc": "The standard deviation of the length in time steps of the active buying period. "                      "Required for Normal active_buying_frequency_type. Must be greater than or equal to 0 ",                      "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "uilabel": "Active Buying Frequency Standard Deviation"}
#line 308 "/cycamore/src/storage.h"
  double active_buying_stddev;
  std::vector<int> cycpp_shape_active_buying_stddev;
#line 309 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip": "Probability that agent will go offline during the next time step",                      "doc": "Binomial distribution has a fixed probability of going dormant at any given "                      "timestep, like a weighted coin flip. Required for Binomial active_buying_frequency_type. "                      "Must be between 0 and 1",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Active Buying Offline Probability"}
#line 318 "/cycamore/src/storage.h"
  double active_buying_end_probability;
  std::vector<int> cycpp_shape_active_buying_end_probability;
#line 319 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip": "Probability that a cycle contains a disruption",                      "doc": "Probability that the agent undergoes a disruption (disrupted active period) "                      "during any given cycle. Required for FixedWithDisruption active_buying_frequency_type.",                      "uitype": "range",                      "range": [0.0, 1.0],                      "uilabel": "Active Buying Disruption Probability"}
#line 327 "/cycamore/src/storage.h"
  double active_buying_disruption_probability;
  std::vector<int> cycpp_shape_active_buying_disruption_probability;
#line 328 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Fixed length of disrupted active cycle",                      "doc": "When a active cycle is disrupted, this is length of the active period instead "                      "of active_buying_val. Required for FixedWithDisruption active_buying_frequency_type",                      "uitype": "range",                      "range": [0, CY_LARGE_INT]}
#line 335 "/cycamore/src/storage.h"
  int active_buying_disruption;
  std::vector<int> cycpp_shape_active_buying_disruption;
#line 336 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": "Fixed",                      "tooltip": "Type of dormant buying frequency",                      "doc": "Options: Fixed, Uniform, Normal, Binomial, FixedWithDisruption. "                      "Fixed requires dormant_buying_val. "                      "Uniform requires dormant_buying_min and dormant_buying_max. Normal requires "                      "dormant_buying_mean and dormant_buying_std, with optional dormant_buying_min "                      "and dormant_buying_max. Binomial requires dormant_buying_end_probability. "                      "FixedWithDisruption has a probability that any given cycle will have a disrupted, "                      "or long, outage.  Once per cycle, a Bernoulli distribution (Binomial dist "                      "with N=1) will be sampled to determine if typical or disrupted cycle. If typical, "                      "dormant_buying_val is cycle length. If disrupted, dormant_buying_disruption.",                      "uitype": "combobox",                      "categorical": ["Fixed", "Uniform", "Normal", "Binomial", "FixedWithDisruption"],                      "uilabel": "Dormant Buying Frequency Type"}
#line 351 "/cycamore/src/storage.h"
  std::string dormant_buying_frequency_type;
  std::vector<int> cycpp_shape_dormant_buying_frequency_type;
#line 352 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Fixed dormant buying frequency",                      "doc": "The length in time steps of the dormant buying period. Required for fixed "                      "dormant_buying_frequency_type. Default is -1, agent has no dormant period and stays active.",                      "uitype": "range",                       "range": [-1, CY_LARGE_INT],                       "uilabel": "Dormant Buying Frequency Value"}
#line 360 "/cycamore/src/storage.h"
  int dormant_buying_val;
  std::vector<int> cycpp_shape_dormant_buying_val;
#line 361 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Dormant buying distribution minimum",                      "doc": "The minimum length in time steps of the dormant buying period. Required for Uniform and optional for "                      "Normal dormant_buying_frequency_type.",                      "uitype": "range",                       "range": [0, CY_LARGE_INT],                       "uilabel": "Dormant Buying Frequency Minimum"}
#line 369 "/cycamore/src/storage.h"
  int dormant_buying_min;
  std::vector<int> cycpp_shape_dormant_buying_min;
#line 370 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Dormant buying distribution maximum",                      "doc": "The maximum length in time steps of the dormant buying period. Required for "                      "Uniform dormant_buying_frequency_type, optional for Normal. Must be greater than or equal to dormant_buying_min ",                      "uitype": "range",                       "range": [0, CY_LARGE_INT],                       "uilabel": "Dormant Buying Frequency Maximum"}
#line 378 "/cycamore/src/storage.h"
  int dormant_buying_max;
  std::vector<int> cycpp_shape_dormant_buying_max;
#line 379 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Dormant buying distribution mean",                      "doc": "The mean length in time steps of the dormant buying period. Required for "                      "Normal dormant_buying_frequency_type. Must be greater than or equal to 0 ",                      "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "uilabel": "Dormant Buying Frequency Mean"}
#line 387 "/cycamore/src/storage.h"
  double dormant_buying_mean;
  std::vector<int> cycpp_shape_dormant_buying_mean;
#line 388 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Dormant buying distribution standard deviation",                      "doc": "The standard deviation of the length in time steps of the dormant buying period. "                      "Required for Normal dormant_buying_frequency_type. Must be greater than or equal to 0 ",                      "uitype": "range",                       "range": [0.0, CY_LARGE_DOUBLE],                       "uilabel": "Dormant Buying Frequency Standard Deviation"}
#line 396 "/cycamore/src/storage.h"
  double dormant_buying_stddev;
  std::vector<int> cycpp_shape_dormant_buying_stddev;
#line 397 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip": "Probability that agent will return to active during the next time step",                      "doc": "Binomial distribution has a fixed probability of going active at any given "                      "timestep, like a weighted coin flip. Required for Binomial dormant_buying_frequency_type. "                      "Must be between 0 and 1",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Dormant Buying Binomial Offline Probability"}
#line 406 "/cycamore/src/storage.h"
  double dormant_buying_end_probability;
  std::vector<int> cycpp_shape_dormant_buying_end_probability;
#line 407 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 0,                      "tooltip": "Probability that a cycle contains a disruption",                      "doc": "Probability that the agent undergoes a disruption (longer offline period) "                      "during any given cycle. Required for FixedWithDisruption dormant_buying_frequency_type.",                      "uitype": "range",                      "range": [0.0, 1.0],                      "uilabel": "Dormant Buying Disruption Probability"}
#line 415 "/cycamore/src/storage.h"
  double dormant_buying_disruption_probability;
  std::vector<int> cycpp_shape_dormant_buying_disruption_probability;
#line 416 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Fixed length of disrupted cycle",                      "doc": "When a dormant cycle is disrupted, this is length of the offline period instead "                      "of dormant_buying_val. Required for FixedWithDisruption dormant_buying_frequency_type",                      "uitype": "range",                      "range": [0, CY_LARGE_INT]}
#line 423 "/cycamore/src/storage.h"
  int dormant_buying_disruption;
  std::vector<int> cycpp_shape_dormant_buying_disruption;
#line 424 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": "Fixed",                      "tooltip": "Type of behavior used to determine size of buy request",                      "doc": "Behavior function used to determine the size of requests made. All values are "                      "a fraction of maximum capacity, determined by the throughput and capacity remaining."                      " Options: Fixed, Uniform, Normal. Fixed is default behavior. Uniform requires "                      "buying_size_min and buying_size_max. Normal requires "                      "buying_size_mean and buying_size_stddev, optional buying_size_min and "                      "buying_size_max.",                      "uitype": "combobox",                      "categorical": ["Fixed", "Uniform", "Normal"],                      "uilabel": "Buying Size Type"}
#line 436 "/cycamore/src/storage.h"
  std::string buying_size_type;
  std::vector<int> cycpp_shape_buying_size_type;
#line 437 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": 1.0,                      "tooltip": "Fixed buying size",                      "doc": "The size of the buy request as a fraction of maximum capacity. Optional for Fixed "                      "buying_size_type. Must be greater than or equal to 0.0",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Buying Size Value"}
#line 445 "/cycamore/src/storage.h"
  double buying_size_val;
  std::vector<int> cycpp_shape_buying_size_val;
#line 446 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1.0,                      "tooltip": "Buying size distribution minimum",                      "doc": "The minimum size of the buy request as a fraction of maximum capacity. "                      "Required for Uniform and optional for Normal buying_size_type. Must be greater than "                      "or equal to zero.",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Buying Size Minimum"}
#line 455 "/cycamore/src/storage.h"
  double buying_size_min;
  std::vector<int> cycpp_shape_buying_size_min;
#line 456 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1.0,                      "tooltip": "Buying size distribution maximum",                      "doc": "The maximum size of the buy request as a fraction of maximum capacity. "                      "Required for Uniform buying_size_type, optional for Normal. Must be greater than "                      "or equal to buying_size_min ",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Buying Size Maximum"}
#line 465 "/cycamore/src/storage.h"
  double buying_size_max;
  std::vector<int> cycpp_shape_buying_size_max;
#line 466 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1.0,                      "tooltip": "Buying size distribution mean",                      "doc": "The mean size of the buy request as a fraction of maximum capacity. "                      "Required for Normal buying_size_type.",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Buying Size Mean"}
#line 474 "/cycamore/src/storage.h"
  double buying_size_mean;
  std::vector<int> cycpp_shape_buying_size_mean;
#line 475 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1.0,                      "tooltip": "Buying size distribution standard deviation",                      "doc": "The standard deviation of the size of the buy request as a fraction of "                      "maximum capacity. Required for Normal buying_size_type.",                      "uitype": "range",                       "range": [0.0, 1.0],                       "uilabel": "Buying Size Standard Deviation"}
#line 483 "/cycamore/src/storage.h"
  double buying_size_stddev;
  std::vector<int> cycpp_shape_buying_size_stddev;
#line 484 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip":"Reorder point",                      "doc":"The point at which the facility will request more material. "                      "Above this point, no request will be made. Must be less than max_inv_size."                      "If paired with reorder_quantity, this agent will have an (R,Q) inventory policy. "                      "If reorder_point is used alone, this agent will have an (s,S) inventory policy, "                      " with S (the maximum) being set at max_inv_size.",                      "uilabel":"Reorder Point"}
#line 493 "/cycamore/src/storage.h"
  double reorder_point;
  std::vector<int> cycpp_shape_reorder_point;
#line 494 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip":"Reorder amount (R,Q inventory policy)",                      "doc":"The amount of material that will be requested when the reorder point is reached. "                      "Exclusive request, so will demand exactly reorder_quantity."                      "Reorder_point + reorder_quantity must be less than max_inv_size.",                      "uilabel":"Reorder Quantity"}
#line 501 "/cycamore/src/storage.h"
  double reorder_quantity;
  std::vector<int> cycpp_shape_reorder_quantity;
#line 502 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": -1,                      "tooltip": "Total amount of material that can be recieved per cycle.",                      "doc": "After receiving this much material cumulatively, the agent will go dormant. "                      "Must be paired with dormant_buying_frequency_type and any other dormant parameters. "                      "The per-time step demand is unchanged except the cycle cap is almost reached.",                      "uilabel": "Cumulative Cap"}
#line 509 "/cycamore/src/storage.h"
  double cumulative_cap;
  std::vector<int> cycpp_shape_cumulative_cap;
#line 510 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": "unpackaged",                       "tooltip": "Output package",                       "doc": "Outgoing material will be packaged when trading.",                       "uitype": "package",                       "uilabel": "Package"}
#line 516 "/cycamore/src/storage.h"
  std::string package;
  std::vector<int> cycpp_shape_package;
#line 517 "/cycamore/src/storage.h"
 
 
  #pragma cyclus var {"default": "unrestricted",                       "tooltip": "Output transport unit",                       "doc": "Outgoing material, after packaging, will be "                      "further restricted by transport unit when trading.",                       "uitype": "transportunit",                       "uilabel": "Transport Unit"}
#line 524 "/cycamore/src/storage.h"
  std::string transport_unit;
  std::vector<int> cycpp_shape_transport_unit;
 
#line 525 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"Incoming material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> inventory;
  std::vector<int> cycpp_shape_inventory;
 
#line 528 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"Output material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> stocks;
  std::vector<int> cycpp_shape_stocks;
 
#line 531 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"Buffer for material held for required residence_time"}
  cyclus::toolkit::ResBuf<cyclus::Material> ready;
  std::vector<int> cycpp_shape_ready;
 
#line 534 "/cycamore/src/storage.h"
 
  #pragma cyclus var{"default": [],                      "internal": True}
#line 538 "/cycamore/src/storage.h"
  std::list<int> entry_times;
 
  #pragma cyclus var {"tooltip":"Buffer for material still waiting for required residence_time"}
  cyclus::toolkit::ResBuf<cyclus::Material> processing;
  std::vector<int> cycpp_shape_processing;
 
#line 542 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip": "Total Inventory Tracker to restrict maximum agent inventory"}
  cyclus::toolkit::TotalInvTracker inventory_tracker;
  std::vector<int> cycpp_shape_inventory_tracker;
 
#line 545 "/cycamore/src/storage.h"
 
  cyclus::toolkit::MatlBuyPolicy buy_policy;
 
  cyclus::toolkit::MatlSellPolicy sell_policy;
 
  #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 558 "/cycamore/src/storage.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 559 "/cycamore/src/storage.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 566 "/cycamore/src/storage.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 567 "/cycamore/src/storage.h"
 
  cyclus::IntDistribution::Ptr active_dist_ = NULL;
  cyclus::IntDistribution::Ptr dormant_dist_ = NULL;
  cyclus::DoubleDistribution::Ptr size_dist_ = NULL;
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
 
  friend class StorageTest;
};
 
}  // namespace cycamore
 
#endif  // CYCLUS_STORAGES_STORAGE_H_