src/storage.h

Go to the documentation of this file.

#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);
 
  #pragma cyclus decl
 
  #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."}

  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"]}
  std::vector<std::string> in_commods;
 
  #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"]}
  std::vector<double> in_commod_prefs;
 
  #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"]}
  std::vector<std::string> out_commods;
 
  #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"}
  std::string in_recipe;
 
  #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]}
  int residence_time;
 
  #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"}
  double throughput;
 
  #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"}
  double max_inv_size;
 
  #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"}
  bool discrete_handling;
 
  #pragma cyclus var {"default": "unpackaged", \
                      "tooltip": "Output package", \
                      "doc": "Outgoing material will be packaged when trading.", \
                      "uitype": "package", \
                      "uilabel": "Package"}
  std::string package;
 
  #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"}
  std::string transport_unit;
 
  #pragma cyclus var {"tooltip":"Incoming material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> inventory;
 
  #pragma cyclus var {"tooltip":"Output material buffer"}
  cyclus::toolkit::ResBuf<cyclus::Material> stocks;
 
  #pragma cyclus var {"tooltip":"Buffer for material held for required residence_time"}
  cyclus::toolkit::ResBuf<cyclus::Material> ready;

  #pragma cyclus var{"default": [],\
                      "internal": True}
  std::list<int> entry_times;
 
  #pragma cyclus var {"tooltip":"Buffer for material still waiting for required residence_time"}
  cyclus::toolkit::ResBuf<cyclus::Material> processing;
 
  #pragma cyclus var {"tooltip": "Total Inventory Tracker to restrict maximum agent inventory"}
  cyclus::toolkit::TotalInvTracker inventory_tracker;
 
  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_