build/cycamore/reactor.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/reactor.h"
#ifndef CYCAMORE_SRC_REACTOR_H_
#define CYCAMORE_SRC_REACTOR_H_
 
#include "cyclus.h"
#include "cycamore_version.h"
 
namespace cycamore {
 
 
class Reactor : public cyclus::Facility,
  public cyclus::toolkit::CommodityProducer,
  public cyclus::toolkit::Position {
#pragma cyclus note { "niche": "reactor", "doc":   "Reactor is a simple, general reactor based on static compositional"   " transformations to model fuel burnup.  The user specifies a set of input"   " fuels and corresponding burnt compositions that fuel is transformed to when"   " it is discharged from the core.  No incremental transmutation takes place."   " Rather, at the end of an operational cycle, the batch being discharged from"   " the core is instantaneously transmuted from its original fresh fuel"   " composition into its spent fuel form."   "\n\n"   "Each fuel is identified by a specific input commodity and has an associated"   " input recipe (nuclide composition), output recipe, output commidity, and"   " preference.  The preference identifies which input fuels are preferred when"   " requesting.  Changes in these preferences can be specified as a function of"   " time using the pref_change variables.  Changes in the input-output recipe"   " compositions can also be specified as a function of time using the"   " recipe_change variables."   "\n\n"   "The reactor treats fuel as individual assemblies that are never split,"   " combined or otherwise treated in any non-discrete way.  Fuel is requested"   " in full-or-nothing assembly sized quanta.  If real-world assembly modeling"   " is unnecessary, parameters can be adjusted (e.g. n_assem_core, assem_size,"   " n_assem_batch).  At the end of every cycle, a full batch is discharged from"   " the core consisting of n_assem_batch assemblies of assem_size kg. The"   " reactor also has a specifiable refueling time period following the end of"   " each cycle at the end of which it will resume operation on the next cycle"   " *if* it has enough fuel for a full core; otherwise it waits until it has"   " enough fresh fuel assemblies."   "\n\n"   "In addition to its core, the reactor has an on-hand fresh fuel inventory"   " and a spent fuel inventory whose capacities are specified by n_assem_fresh"   " and n_assem_spent respectively.  Each time step the reactor will attempt to"   " acquire enough fresh fuel to fill its fresh fuel inventory (and its core if"   " the core isn't currently full).  If the fresh fuel inventory has zero"   " capacity, fuel will be ordered just-in-time after the end of each"   " operational cycle before the next begins.  If the spent fuel inventory"   " becomes full, the reactor will halt operation at the end of the next cycle"   " until there is more room.  Each time step, the reactor will try to trade"   " away as much of its spent fuel inventory as possible."   "\n\n"   "When the reactor reaches the end of its lifetime, it will discharge all"   " material from its core and trade away all its spent fuel as quickly as"   " possible.  Full decommissioning will be delayed until all spent fuel is"   " gone.  If the reactor has a full core when it is decommissioned (i.e. is"   " mid-cycle) when the reactor is decommissioned, half (rounded up to nearest"   " int) of its assemblies are transmuted to their respective burnt"   " compositions."   "", }
#line 108 "/cycamore/src/reactor.h"
 
 public:
  Reactor(cyclus::Context* ctx);
  virtual ~Reactor(){};
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
  virtual void Tick();
  virtual void Tock();
  virtual void EnterNotify();
  virtual bool CheckDecommissionCondition();
 
  virtual void AcceptMatlTrades(const std::vector<std::pair<
      cyclus::Trade<cyclus::Material>, cyclus::Material::Ptr> >& responses);
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
  GetMatlRequests();
 
  virtual std::set<cyclus::BidPortfolio<cyclus::Material>::Ptr> GetMatlBids(
      cyclus::CommodMap<cyclus::Material>::type& commod_requests);
 
  virtual void GetMatlTrades(
      const std::vector<cyclus::Trade<cyclus::Material> >& trades,
      std::vector<std::pair<cyclus::Trade<cyclus::Material>,
                            cyclus::Material::Ptr> >& responses);
  virtual void InitFrom(cycamore::Reactor* m);
#line 133 "/cycamore/src/reactor.h"
 
  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 135 "/cycamore/src/reactor.h"
 
 private:
  std::string fuel_incommod(cyclus::Material::Ptr m);
  std::string fuel_outcommod(cyclus::Material::Ptr m);
  std::string fuel_inrecipe(cyclus::Material::Ptr m);
  std::string fuel_outrecipe(cyclus::Material::Ptr m);
  double fuel_pref(cyclus::Material::Ptr m);
 
  bool retired() {
    return exit_time() != -1 && context()->time() > exit_time();
  }
 
  void index_res(cyclus::Resource::Ptr m, std::string incommod);
 
  bool Discharge();
 
  void Load();
 
  void Transmute();
 
  void RecordSideProduct(bool produce);
 
  void Transmute(int n_assem);
 
  void Record(std::string name, std::string val);
 
  void PushSpent(std::map<std::string, cyclus::toolkit::MatVec> leftover);
 
  std::map<std::string, cyclus::toolkit::MatVec> PopSpent();
 
  std::map<std::string, cyclus::toolkit::MatVec> PeekSpent();
 
  #pragma cyclus var {     "uitype": ["oneormore", "incommodity"],     "uilabel": "Fresh Fuel Commodity List",     "doc": "Ordered list of input commodities on which to requesting fuel.",   }
#line 189 "/cycamore/src/reactor.h"
  std::vector<std::string> fuel_incommods;
  std::vector<int> cycpp_shape_fuel_incommods;
 
  #pragma cyclus var {     "uitype": ["oneormore", "inrecipe"],     "uilabel": "Fresh Fuel Recipe List",     "doc": "Fresh fuel recipes to request for each of the given fuel input "            "commodities (same order).",   }
#line 196 "/cycamore/src/reactor.h"
  std::vector<std::string> fuel_inrecipes;
  std::vector<int> cycpp_shape_fuel_inrecipes;
#line 197 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "default": [],     "uilabel": "Fresh Fuel Preference List",     "doc": "The preference for each type of fresh fuel requested corresponding"           " to each input commodity (same order).  If no preferences are "            "specified, 1.0 is used for all fuel "            "requests (default).",   }
#line 206 "/cycamore/src/reactor.h"
  std::vector<double> fuel_prefs;
  std::vector<int> cycpp_shape_fuel_prefs;
 
  #pragma cyclus var {     "uitype": ["oneormore", "outcommodity"],     "uilabel": "Spent Fuel Commodity List",     "doc": "Output commodities on which to offer spent fuel originally "            "received as each particular input commodity (same order)."   }
#line 213 "/cycamore/src/reactor.h"
  std::vector<std::string> fuel_outcommods;
  std::vector<int> cycpp_shape_fuel_outcommods;
 
  #pragma cyclus var {               "uitype": ["oneormore", "outrecipe"],     "uilabel": "Spent Fuel Recipe List",     "doc": "Spent fuel recipes corresponding to the given fuel input "            "commodities (same order)."            " Fuel received via a particular input commodity is transmuted to "            "the recipe specified here after being burned during a cycle.",   }
#line 222 "/cycamore/src/reactor.h"
  std::vector<std::string> fuel_outrecipes;
  std::vector<int> cycpp_shape_fuel_outrecipes;
 
#line 223 "/cycamore/src/reactor.h"
 
  #pragma cyclus var {     "default": [],     "uilabel": "Time to Change Fresh/Spent Fuel Recipe",     "doc": "A time step on which to change the input-output recipe pair for "            "a requested fresh fuel.",   }
#line 231 "/cycamore/src/reactor.h"
  std::vector<int> recipe_change_times;
  std::vector<int> cycpp_shape_recipe_change_times;
 
  #pragma cyclus var {     "default": [],     "uilabel": "Commodity for Changed Fresh/Spent Fuel Recipe",     "doc": "The input commodity indicating fresh fuel for which recipes will "            "be changed. Same order as and direct correspondence to the "            "specified recipe change times.",     "uitype": ["oneormore", "incommodity"],   }
#line 240 "/cycamore/src/reactor.h"
  std::vector<std::string> recipe_change_commods;
  std::vector<int> cycpp_shape_recipe_change_commods;
 
  #pragma cyclus var {     "default": [],     "uilabel": "New Recipe for Fresh Fuel",     "doc": "The new input recipe to use for this recipe change."            " Same order as and direct correspondence to the specified recipe "            "change times.",     "uitype": ["oneormore", "inrecipe"],   }
#line 249 "/cycamore/src/reactor.h"
  std::vector<std::string> recipe_change_in;
  std::vector<int> cycpp_shape_recipe_change_in;
 
  #pragma cyclus var {     "default": [],     "uilabel": "New Recipe for Spent Fuel",     "doc": "The new output recipe to use for this recipe change."            " Same order as and direct correspondence to the specified recipe "            "change times.",     "uitype": ["oneormore", "outrecipe"],   }
#line 258 "/cycamore/src/reactor.h"
  std::vector<std::string> recipe_change_out;
  std::vector<int> cycpp_shape_recipe_change_out;
 
#line 259 "/cycamore/src/reactor.h"
 
  #pragma cyclus var {     "doc": "Mass (kg) of a single assembly.",     "uilabel": "Assembly Mass",     "uitype": "range",     "range": [1.0, 1e5],     "units": "kg",   }
#line 268 "/cycamore/src/reactor.h"
  double assem_size;
  std::vector<int> cycpp_shape_assem_size;
#line 269 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "uilabel": "Number of Assemblies per Batch",     "doc": "Number of assemblies that constitute a single batch.  "            "This is the number of assemblies discharged from the core fully "            "burned each cycle."                      "Batch size is equivalent to ``n_assem_batch / n_assem_core``.",   }
#line 277 "/cycamore/src/reactor.h"
  int n_assem_batch;
  std::vector<int> cycpp_shape_n_assem_batch;
 
  #pragma cyclus var {     "default": 3,     "uilabel": "Number of Assemblies in Core",     "uitype": "range",     "range": [1,3],     "doc": "Number of assemblies that constitute a full core.",   }
#line 285 "/cycamore/src/reactor.h"
  int n_assem_core;
  std::vector<int> cycpp_shape_n_assem_core;
 
  #pragma cyclus var {     "default": 0,     "uilabel": "Minimum Fresh Fuel Inventory",     "uitype": "range",     "range": [0,3],     "units": "assemblies",     "doc": "Number of fresh fuel assemblies to keep on-hand if possible.",   }
#line 294 "/cycamore/src/reactor.h"
  int n_assem_fresh;
  std::vector<int> cycpp_shape_n_assem_fresh;
 
  #pragma cyclus var {     "default": 1000000000,     "uilabel": "Maximum Spent Fuel Inventory",     "uitype": "range",     "range": [0, 1000000000],     "units": "assemblies",     "doc": "Number of spent fuel assemblies that can be stored on-site before"            " reactor operation stalls.",   }
#line 304 "/cycamore/src/reactor.h"
  int n_assem_spent;
  std::vector<int> cycpp_shape_n_assem_spent;
 
#line 305 "/cycamore/src/reactor.h"
 
  #pragma cyclus var {     "default": 18,     "doc": "The duration of a full operational cycle (excluding refueling "            "time) in time steps.",     "uilabel": "Cycle Length",     "units": "time steps",   }
#line 314 "/cycamore/src/reactor.h"
  int cycle_time;
  std::vector<int> cycpp_shape_cycle_time;
 
  #pragma cyclus var {     "default": 1,     "doc": "The duration of a full refueling period - the minimum time between"           " the end of a cycle and the start of the next cycle.",     "uilabel": "Refueling Outage Duration",     "units": "time steps",   }
#line 322 "/cycamore/src/reactor.h"
  int refuel_time;
  std::vector<int> cycpp_shape_refuel_time;
 
  #pragma cyclus var {     "default": 0,     "doc": "Number of time steps since the start of the last cycle."            " Only set this if you know what you are doing",     "uilabel": "Time Since Start of Last Cycle",     "units": "time steps",   }
#line 330 "/cycamore/src/reactor.h"
  int cycle_step;
  std::vector<int> cycpp_shape_cycle_step;
 
#line 331 "/cycamore/src/reactor.h"
 
  #pragma cyclus var {     "default": 0,     "doc": "Amount of electrical power the facility produces when operating "            "normally.",     "uilabel": "Nominal Reactor Power",     "uitype": "range",     "range": [0.0, 2000.00],      "units": "MWe",   }
#line 342 "/cycamore/src/reactor.h"
  double power_cap;
  std::vector<int> cycpp_shape_power_cap;
#line 343 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "default": "power",     "uilabel": "Power Commodity Name",     "doc": "The name of the 'power' commodity used in conjunction with a "            "deployment curve.",   }
#line 350 "/cycamore/src/reactor.h"
  std::string power_name;
  std::vector<int> cycpp_shape_power_name;
 
#line 351 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "uilabel": "Side Product from Reactor Plant",     "default": [],     "doc": "Ordered vector of side product the reactor produces with power",   }
#line 359 "/cycamore/src/reactor.h"
  std::vector<std::string> side_products;
  std::vector<int> cycpp_shape_side_products;
#line 360 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "uilabel": "Quantity of Side Product from Reactor Plant",     "default": [],     "doc": "Ordered vector of the quantity of side product the reactor produces with power",   }
#line 366 "/cycamore/src/reactor.h"
  std::vector<double> side_product_quantity;
  std::vector<int> cycpp_shape_side_product_quantity;
#line 367 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {"default": 1,                      "internal": True,                      "doc": "True if reactor is a hybrid system (produces side products)",   }
#line 372 "/cycamore/src/reactor.h"
  bool hybrid_;
  std::vector<int> cycpp_shape_hybrid_;
 
#line 373 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {"default": 0,                       "uilabel": "Boolean for transmutation behavior upon decommissioning.",                       "doc": "If true, the archetype transmutes all assemblies upon decommissioning "                              "If false, the archetype only transmutes half.",   }
#line 381 "/cycamore/src/reactor.h"
  bool decom_transmute_all;
  std::vector<int> cycpp_shape_decom_transmute_all;
 
#line 382 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "default": [],     "uilabel": "Time to Change Fresh Fuel Preference",     "doc": "A time step on which to change the request preference for a "            "particular fresh fuel type.",   }
#line 391 "/cycamore/src/reactor.h"
  std::vector<int> pref_change_times;
  std::vector<int> cycpp_shape_pref_change_times;
 
  #pragma cyclus var {     "default": [],     "doc": "The input commodity for a particular fuel preference change.  "            "Same order as and direct correspondence to the specified "            "preference change times.",     "uilabel": "Commodity for Changed Fresh Fuel Preference",     "uitype": ["oneormore", "incommodity"],   }
#line 400 "/cycamore/src/reactor.h"
  std::vector<std::string> pref_change_commods;
  std::vector<int> cycpp_shape_pref_change_commods;
 
  #pragma cyclus var {     "default": [],     "uilabel": "Changed Fresh Fuel Preference",                            "doc": "The new/changed request preference for a particular fresh fuel."            " Same order as and direct correspondence to the specified "            "preference change times.",   }
#line 408 "/cycamore/src/reactor.h"
  std::vector<double> pref_change_values;
  std::vector<int> cycpp_shape_pref_change_values;
#line 409 "/cycamore/src/reactor.h"
 
 
  #pragma cyclus var {     "default": True,     "tooltip": "Whether to persist packaging throughout the reactor",     "doc": "Boolean value about whether to keep packaging. If true, "            "packaging will not be stripped upon acceptance into the "            "reactor. 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 420 "/cycamore/src/reactor.h"
  bool keep_packaging;
  std::vector<int> cycpp_shape_keep_packaging;
 
#line 421 "/cycamore/src/reactor.h"
 
  // Resource inventories - these must be defined AFTER/BELOW the member vars
  // referenced (e.g. n_batch_fresh, assem_size, etc.).
  #pragma cyclus var {"capacity": "n_assem_fresh * assem_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> fresh;
  std::vector<int> cycpp_shape_fresh;
 
#line 426 "/cycamore/src/reactor.h"
  #pragma cyclus var {"capacity": "n_assem_core * assem_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> core;
  std::vector<int> cycpp_shape_core;
 
#line 428 "/cycamore/src/reactor.h"
  #pragma cyclus var {"capacity": "n_assem_spent * assem_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> spent;
  std::vector<int> cycpp_shape_spent;
 
#line 430 "/cycamore/src/reactor.h"
 
 
  // should be hidden in ui (internal only). True if fuel has already been
  // discharged this cycle.
  #pragma cyclus var {"default": 0, "doc": "This should NEVER be set manually",                      "internal": True   }
#line 437 "/cycamore/src/reactor.h"
  bool discharged;
  std::vector<int> cycpp_shape_discharged;
 
#line 438 "/cycamore/src/reactor.h"
 
  // This variable should be hidden/unavailable in ui.  Maps resource object
  // id's to the index for the incommod through which they were received.
  #pragma cyclus var {"default": {}, "doc": "This should NEVER be set manually",                       "internal": True   }
#line 444 "/cycamore/src/reactor.h"
  std::map<int, int> res_indexes;
  std::vector<int> cycpp_shape_res_indexes;
 
#line 445 "/cycamore/src/reactor.h"
 
  // populated lazily and no need to persist.
  std::set<std::string> uniq_outcommods_;
 
  #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 455 "/cycamore/src/reactor.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 456 "/cycamore/src/reactor.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 463 "/cycamore/src/reactor.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 464 "/cycamore/src/reactor.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
 
} // namespace cycamore
 
#endif  // CYCAMORE_SRC_REACTOR_H_