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:  
  Storage(cyclus::Context* ctx);
  virtual void InitFrom(cycamore::Storage* m);
#line 73 "/cycamore/src/storage.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b);
#line 75 "/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 86 "/cycamore/src/storage.h"

  virtual std::string str();

  virtual void EnterNotify();

  virtual void Tick();

  virtual void Tock();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
 protected:
  void AddMat_(cyclus::Material::Ptr mat);

  void BeginProcessing_();

  void ProcessMat_(double cap);

  void ReadyMatl_(int time);
 
  // --- Storage Members ---

  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 --- 
 
  #pragma cyclus var {"tooltip":"input commodity",                      "doc":"commodities accepted by this facility",                      "uilabel":"Input Commodities",                      "uitype":["oneormore","incommodity"]}
#line 136 "/cycamore/src/storage.h"
  std::vector<std::string> in_commods;
  std::vector<int> cycpp_shape_in_commods;
#line 137 "/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 144 "/cycamore/src/storage.h"
  std::vector<double> in_commod_prefs;
  std::vector<int> cycpp_shape_in_commod_prefs;
#line 145 "/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 151 "/cycamore/src/storage.h"
  std::vector<std::string> out_commods;
  std::vector<int> cycpp_shape_out_commods;
#line 152 "/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 158 "/cycamore/src/storage.h"
  std::string in_recipe;
  std::vector<int> cycpp_shape_in_recipe;
#line 159 "/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 167 "/cycamore/src/storage.h"
  int residence_time;
  std::vector<int> cycpp_shape_residence_time;
#line 168 "/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 176 "/cycamore/src/storage.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
#line 177 "/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 185 "/cycamore/src/storage.h"
  double max_inv_size;
  std::vector<int> cycpp_shape_max_inv_size;
#line 186 "/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 194 "/cycamore/src/storage.h"
  bool discrete_handling;
  std::vector<int> cycpp_shape_discrete_handling;
#line 195 "/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 201 "/cycamore/src/storage.h"
  std::string package;
  std::vector<int> cycpp_shape_package;
#line 202 "/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 209 "/cycamore/src/storage.h"
  std::string transport_unit;
  std::vector<int> cycpp_shape_transport_unit;
 
#line 210 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"Incoming material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> inventory;
  std::vector<int> cycpp_shape_inventory;
 
#line 213 "/cycamore/src/storage.h"
 
  #pragma cyclus var {"tooltip":"Output material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> stocks;
  std::vector<int> cycpp_shape_stocks;
 
#line 216 "/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 219 "/cycamore/src/storage.h"

  #pragma cyclus var{"default": [],                      "internal": True}
#line 223 "/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 227 "/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 230 "/cycamore/src/storage.h"
 
  friend class StorageTest;
 
 private:
  // Code Injection
  #include "toolkit/matl_buy_policy.cycpp.h"
  #include "toolkit/matl_sell_policy.cycpp.h"
  #include "toolkit/position.cycpp.h"
 
};
 
}  // namespace cycamore
 
#endif  // CYCLUS_STORAGES_STORAGE_H_