build/cycamore/fuel_fab.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/fuel_fab.h"
#ifndef CYCAMORE_SRC_FUEL_FAB_H_
#define CYCAMORE_SRC_FUEL_FAB_H_
 
#include <string>
#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 FuelFab
  : public cyclus::Facility,
    public cyclus::toolkit::Position {
#pragma cyclus note { "niche": "fabrication", "doc":   "FuelFab takes in 2 streams of material and mixes them in ratios in order to"   " supply material that matches some neutronics properties of reqeusted"   " material.  It uses an equivalence type method [1]"   " inspired by a similar approach in the COSI fuel cycle simulator."   "\n\n"   "The FuelFab has 3 input inventories: fissile stream, filler stream, and an"   " optional top-up inventory.  All materials received into each inventory are"   " always combined into a single material (i.e. a single fissile material, a"   " single filler material, etc.).  The input streams and requested fuel"   " composition are each assigned weights based on summing:"   "\n\n"   "    N * (p_i - p_U238) / (p_Pu239 - p_U238)"   "\n\n"   "for each nuclide where:"   "\n"   "\n    - p = nu*sigma_f - sigma_a   for the nuclide"   "\n    - p_U238 is p for pure U238"   "\n    - p_Pu239 is p for pure Pu239"   "\n    - N is the nuclide's atom fraction"   "\n    - nu is the average # neutrons per fission"   "\n    - sigma_f is the microscopic fission cross-section"   "\n    - sigma_a is the microscopic neutron absorption cross-section"   "\n\n"   "The cross sections are from the simple cross section library in PyNE. They"   " can be set to either a thermal or fast neutron spectrum.  A linear"   " interpolation is performed using the weights of the fissile, filler, and"   " target streams. The interpolation is used to compute a mixing ratio of the"   " input streams that matches the target weight.  In the event that the target"   " weight is higher than the fissile stream weight, the FuelFab will attempt"   " to use the top-up and fissile input streams together instead of the fissile"   " and filler streams.  All supplied material will always have the same weight"   " as the requested material."   "\n\n"   "The supplying of mixed material is constrained by available inventory"   " quantities and a per time step throughput limit.  Requests for fuel"   " material larger than the throughput can never be met.  Fissile inventory"   " can be requested/received via one or more commodities.  The DRE request"   " preference for each of these commodities can also optionally be specified."   " By default, the top-up inventory size is zero, and it is not used for"   " mixing. "   "\n\n"   "[1] Baker, A. R., and R. W. Ross. \"Comparison of the value of plutonium and"   "    uranium isotopes in fast reactors.\" Proceedings of the Conference on"   "    Breeding. Economics, and Safety in Large Fast Power Reactors. 1963."   "", }
#line 110 "/cycamore/src/fuel_fab.h"
 public:
  FuelFab(cyclus::Context* ctx);
  virtual ~FuelFab(){};
 
  virtual std::string version() { return CYCAMORE_VERSION; }
  virtual void InitFrom(cycamore::FuelFab* m) {
    cyclus::Facility::InitFrom(m);
    int rawcycpp_shape_fill_commods[2] = {-1, -1};
    cycpp_shape_fill_commods = std::vector<int>(rawcycpp_shape_fill_commods, rawcycpp_shape_fill_commods + 2);
    int rawcycpp_shape_fill_commod_prefs[2] = {-1, -1};
    cycpp_shape_fill_commod_prefs = std::vector<int>(rawcycpp_shape_fill_commod_prefs, rawcycpp_shape_fill_commod_prefs + 2);
    int rawcycpp_shape_fill_recipe[1] = {-1};
    cycpp_shape_fill_recipe = std::vector<int>(rawcycpp_shape_fill_recipe, rawcycpp_shape_fill_recipe + 1);
    int rawcycpp_shape_fill_size[1] = {-1};
    cycpp_shape_fill_size = std::vector<int>(rawcycpp_shape_fill_size, rawcycpp_shape_fill_size + 1);
    int rawcycpp_shape_fill[2] = {-1, -1};
    cycpp_shape_fill = std::vector<int>(rawcycpp_shape_fill, rawcycpp_shape_fill + 2);
    int rawcycpp_shape_fiss_commods[2] = {-1, -1};
    cycpp_shape_fiss_commods = std::vector<int>(rawcycpp_shape_fiss_commods, rawcycpp_shape_fiss_commods + 2);
    int rawcycpp_shape_fiss_commod_prefs[2] = {-1, -1};
    cycpp_shape_fiss_commod_prefs = std::vector<int>(rawcycpp_shape_fiss_commod_prefs, rawcycpp_shape_fiss_commod_prefs + 2);
    int rawcycpp_shape_fiss_recipe[1] = {-1};
    cycpp_shape_fiss_recipe = std::vector<int>(rawcycpp_shape_fiss_recipe, rawcycpp_shape_fiss_recipe + 1);
    int rawcycpp_shape_fiss_size[1] = {-1};
    cycpp_shape_fiss_size = std::vector<int>(rawcycpp_shape_fiss_size, rawcycpp_shape_fiss_size + 1);
    int rawcycpp_shape_fiss[2] = {-1, -1};
    cycpp_shape_fiss = std::vector<int>(rawcycpp_shape_fiss, rawcycpp_shape_fiss + 2);
    int rawcycpp_shape_topup_commod[1] = {-1};
    cycpp_shape_topup_commod = std::vector<int>(rawcycpp_shape_topup_commod, rawcycpp_shape_topup_commod + 1);
    int rawcycpp_shape_topup_pref[1] = {-1};
    cycpp_shape_topup_pref = std::vector<int>(rawcycpp_shape_topup_pref, rawcycpp_shape_topup_pref + 1);
    int rawcycpp_shape_topup_recipe[1] = {-1};
    cycpp_shape_topup_recipe = std::vector<int>(rawcycpp_shape_topup_recipe, rawcycpp_shape_topup_recipe + 1);
    int rawcycpp_shape_topup_size[1] = {-1};
    cycpp_shape_topup_size = std::vector<int>(rawcycpp_shape_topup_size, rawcycpp_shape_topup_size + 1);
    int rawcycpp_shape_topup[2] = {-1, -1};
    cycpp_shape_topup = std::vector<int>(rawcycpp_shape_topup, rawcycpp_shape_topup + 2);
    int rawcycpp_shape_outcommod[1] = {-1};
    cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_spectrum[1] = {-1};
    cycpp_shape_spectrum = std::vector<int>(rawcycpp_shape_spectrum, rawcycpp_shape_spectrum + 1);
    int rawcycpp_shape_latitude[1] = {-1};
    cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
    int rawcycpp_shape_longitude[1] = {-1};
    cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
    fill_commods = m->fill_commods;
    fill_commod_prefs = m->fill_commod_prefs;
    fill_recipe = m->fill_recipe;
    fill_size = m->fill_size;
    fiss_commods = m->fiss_commods;
    fiss_commod_prefs = m->fiss_commod_prefs;
    fiss_recipe = m->fiss_recipe;
    fiss_size = m->fiss_size;
    topup_commod = m->topup_commod;
    topup_pref = m->topup_pref;
    topup_recipe = m->topup_recipe;
    topup_size = m->topup_size;
    outcommod = m->outcommod;
    throughput = m->throughput;
    spectrum = m->spectrum;
    latitude = m->latitude;
    longitude = m->longitude;
    fill.capacity(m->fill.capacity());
    fiss.capacity(m->fiss.capacity());
    topup.capacity(m->topup.capacity());
  };
#line 115 "/cycamore/src/fuel_fab.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b) {
    cyclus::Facility::InitFrom(b);
    int rawcycpp_shape_fill_commods[2] = {-1, -1};
    cycpp_shape_fill_commods = std::vector<int>(rawcycpp_shape_fill_commods, rawcycpp_shape_fill_commods + 2);
    int rawcycpp_shape_fill_commod_prefs[2] = {-1, -1};
    cycpp_shape_fill_commod_prefs = std::vector<int>(rawcycpp_shape_fill_commod_prefs, rawcycpp_shape_fill_commod_prefs + 2);
    int rawcycpp_shape_fill_recipe[1] = {-1};
    cycpp_shape_fill_recipe = std::vector<int>(rawcycpp_shape_fill_recipe, rawcycpp_shape_fill_recipe + 1);
    int rawcycpp_shape_fill_size[1] = {-1};
    cycpp_shape_fill_size = std::vector<int>(rawcycpp_shape_fill_size, rawcycpp_shape_fill_size + 1);
    int rawcycpp_shape_fill[2] = {-1, -1};
    cycpp_shape_fill = std::vector<int>(rawcycpp_shape_fill, rawcycpp_shape_fill + 2);
    int rawcycpp_shape_fiss_commods[2] = {-1, -1};
    cycpp_shape_fiss_commods = std::vector<int>(rawcycpp_shape_fiss_commods, rawcycpp_shape_fiss_commods + 2);
    int rawcycpp_shape_fiss_commod_prefs[2] = {-1, -1};
    cycpp_shape_fiss_commod_prefs = std::vector<int>(rawcycpp_shape_fiss_commod_prefs, rawcycpp_shape_fiss_commod_prefs + 2);
    int rawcycpp_shape_fiss_recipe[1] = {-1};
    cycpp_shape_fiss_recipe = std::vector<int>(rawcycpp_shape_fiss_recipe, rawcycpp_shape_fiss_recipe + 1);
    int rawcycpp_shape_fiss_size[1] = {-1};
    cycpp_shape_fiss_size = std::vector<int>(rawcycpp_shape_fiss_size, rawcycpp_shape_fiss_size + 1);
    int rawcycpp_shape_fiss[2] = {-1, -1};
    cycpp_shape_fiss = std::vector<int>(rawcycpp_shape_fiss, rawcycpp_shape_fiss + 2);
    int rawcycpp_shape_topup_commod[1] = {-1};
    cycpp_shape_topup_commod = std::vector<int>(rawcycpp_shape_topup_commod, rawcycpp_shape_topup_commod + 1);
    int rawcycpp_shape_topup_pref[1] = {-1};
    cycpp_shape_topup_pref = std::vector<int>(rawcycpp_shape_topup_pref, rawcycpp_shape_topup_pref + 1);
    int rawcycpp_shape_topup_recipe[1] = {-1};
    cycpp_shape_topup_recipe = std::vector<int>(rawcycpp_shape_topup_recipe, rawcycpp_shape_topup_recipe + 1);
    int rawcycpp_shape_topup_size[1] = {-1};
    cycpp_shape_topup_size = std::vector<int>(rawcycpp_shape_topup_size, rawcycpp_shape_topup_size + 1);
    int rawcycpp_shape_topup[2] = {-1, -1};
    cycpp_shape_topup = std::vector<int>(rawcycpp_shape_topup, rawcycpp_shape_topup + 2);
    int rawcycpp_shape_outcommod[1] = {-1};
    cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_spectrum[1] = {-1};
    cycpp_shape_spectrum = std::vector<int>(rawcycpp_shape_spectrum, rawcycpp_shape_spectrum + 1);
    int rawcycpp_shape_latitude[1] = {-1};
    cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
    int rawcycpp_shape_longitude[1] = {-1};
    cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    fill_commods = qr.GetVal<std::vector< std::string > >("fill_commods");
    fill_commod_prefs = qr.GetVal<std::vector< double > >("fill_commod_prefs");
    fill_recipe = qr.GetVal<std::string>("fill_recipe");
    fill_size = qr.GetVal<double>("fill_size");
    fiss_commods = qr.GetVal<std::vector< std::string > >("fiss_commods");
    fiss_commod_prefs = qr.GetVal<std::vector< double > >("fiss_commod_prefs");
    fiss_recipe = qr.GetVal<std::string>("fiss_recipe");
    fiss_size = qr.GetVal<double>("fiss_size");
    topup_commod = qr.GetVal<std::string>("topup_commod");
    topup_pref = qr.GetVal<double>("topup_pref");
    topup_recipe = qr.GetVal<std::string>("topup_recipe");
    topup_size = qr.GetVal<double>("topup_size");
    outcommod = qr.GetVal<std::string>("outcommod");
    throughput = qr.GetVal<double>("throughput");
    spectrum = qr.GetVal<std::string>("spectrum");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    fill.capacity(fill_size);
    fiss.capacity(fiss_size);
    topup.capacity(topup_size);
  };
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Facility::InfileToDb(tree, di);
    int rawcycpp_shape_fill_commods[2] = {-1, -1};
    cycpp_shape_fill_commods = std::vector<int>(rawcycpp_shape_fill_commods, rawcycpp_shape_fill_commods + 2);
    int rawcycpp_shape_fill_commod_prefs[2] = {-1, -1};
    cycpp_shape_fill_commod_prefs = std::vector<int>(rawcycpp_shape_fill_commod_prefs, rawcycpp_shape_fill_commod_prefs + 2);
    int rawcycpp_shape_fill_recipe[1] = {-1};
    cycpp_shape_fill_recipe = std::vector<int>(rawcycpp_shape_fill_recipe, rawcycpp_shape_fill_recipe + 1);
    int rawcycpp_shape_fill_size[1] = {-1};
    cycpp_shape_fill_size = std::vector<int>(rawcycpp_shape_fill_size, rawcycpp_shape_fill_size + 1);
    int rawcycpp_shape_fill[2] = {-1, -1};
    cycpp_shape_fill = std::vector<int>(rawcycpp_shape_fill, rawcycpp_shape_fill + 2);
    int rawcycpp_shape_fiss_commods[2] = {-1, -1};
    cycpp_shape_fiss_commods = std::vector<int>(rawcycpp_shape_fiss_commods, rawcycpp_shape_fiss_commods + 2);
    int rawcycpp_shape_fiss_commod_prefs[2] = {-1, -1};
    cycpp_shape_fiss_commod_prefs = std::vector<int>(rawcycpp_shape_fiss_commod_prefs, rawcycpp_shape_fiss_commod_prefs + 2);
    int rawcycpp_shape_fiss_recipe[1] = {-1};
    cycpp_shape_fiss_recipe = std::vector<int>(rawcycpp_shape_fiss_recipe, rawcycpp_shape_fiss_recipe + 1);
    int rawcycpp_shape_fiss_size[1] = {-1};
    cycpp_shape_fiss_size = std::vector<int>(rawcycpp_shape_fiss_size, rawcycpp_shape_fiss_size + 1);
    int rawcycpp_shape_fiss[2] = {-1, -1};
    cycpp_shape_fiss = std::vector<int>(rawcycpp_shape_fiss, rawcycpp_shape_fiss + 2);
    int rawcycpp_shape_topup_commod[1] = {-1};
    cycpp_shape_topup_commod = std::vector<int>(rawcycpp_shape_topup_commod, rawcycpp_shape_topup_commod + 1);
    int rawcycpp_shape_topup_pref[1] = {-1};
    cycpp_shape_topup_pref = std::vector<int>(rawcycpp_shape_topup_pref, rawcycpp_shape_topup_pref + 1);
    int rawcycpp_shape_topup_recipe[1] = {-1};
    cycpp_shape_topup_recipe = std::vector<int>(rawcycpp_shape_topup_recipe, rawcycpp_shape_topup_recipe + 1);
    int rawcycpp_shape_topup_size[1] = {-1};
    cycpp_shape_topup_size = std::vector<int>(rawcycpp_shape_topup_size, rawcycpp_shape_topup_size + 1);
    int rawcycpp_shape_topup[2] = {-1, -1};
    cycpp_shape_topup = std::vector<int>(rawcycpp_shape_topup, rawcycpp_shape_topup + 2);
    int rawcycpp_shape_outcommod[1] = {-1};
    cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_spectrum[1] = {-1};
    cycpp_shape_spectrum = std::vector<int>(rawcycpp_shape_spectrum, rawcycpp_shape_spectrum + 1);
    int rawcycpp_shape_latitude[1] = {-1};
    cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
    int rawcycpp_shape_longitude[1] = {-1};
    cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
    cyclus::InfileTree* sub = tree->SubTree("config/*");
    int i;
    int n;
    {
      cyclus::InfileTree* bub = sub->SubTree("fill_commods", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > fill_commods_val;
      fill_commods_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        fill_commods_val[i1] = elem;
      }
      fill_commods = fill_commods_val;
    }
    if (sub->NMatches("fill_commod_prefs") > 0) {
      {
        cyclus::InfileTree* bub = sub->SubTree("fill_commod_prefs", 0);
        cyclus::InfileTree* sub = bub;
        int n1 = sub->NMatches("val");
        std::vector< double > fill_commod_prefs_val;
        fill_commod_prefs_val.resize(n1);
        for (int i1 = 0; i1 < n1; ++i1) {
          double elem;
          {
            double elem_in = cyclus::Query<double>(sub, "val", i1);
            elem = elem_in;
          }
          fill_commod_prefs_val[i1] = elem;
        }
        fill_commod_prefs = fill_commod_prefs_val;
      }
    } else {
      std::vector< double > fill_commod_prefs_tmp;
      fill_commod_prefs_tmp.resize(0);
      {
      }
      fill_commod_prefs = fill_commod_prefs_tmp;
    }
    {
      std::string fill_recipe_val = cyclus::Query<std::string>(sub, "fill_recipe");
      fill_recipe = fill_recipe_val;
    }
    {
      double fill_size_val = cyclus::Query<double>(sub, "fill_size");
      fill_size = fill_size_val;
    }
    {
      cyclus::InfileTree* bub = sub->SubTree("fiss_commods", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > fiss_commods_val;
      fiss_commods_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        fiss_commods_val[i1] = elem;
      }
      fiss_commods = fiss_commods_val;
    }
    if (sub->NMatches("fiss_commod_prefs") > 0) {
      {
        cyclus::InfileTree* bub = sub->SubTree("fiss_commod_prefs", 0);
        cyclus::InfileTree* sub = bub;
        int n1 = sub->NMatches("val");
        std::vector< double > fiss_commod_prefs_val;
        fiss_commod_prefs_val.resize(n1);
        for (int i1 = 0; i1 < n1; ++i1) {
          double elem;
          {
            double elem_in = cyclus::Query<double>(sub, "val", i1);
            elem = elem_in;
          }
          fiss_commod_prefs_val[i1] = elem;
        }
        fiss_commod_prefs = fiss_commod_prefs_val;
      }
    } else {
      std::vector< double > fiss_commod_prefs_tmp;
      fiss_commod_prefs_tmp.resize(0);
      {
      }
      fiss_commod_prefs = fiss_commod_prefs_tmp;
    }
    if (sub->NMatches("fiss_recipe") > 0) {
      {
        std::string fiss_recipe_val = cyclus::Query<std::string>(sub, "fiss_recipe");
        fiss_recipe = fiss_recipe_val;
      }
    } else {
      std::string fiss_recipe_tmp("");
      fiss_recipe = fiss_recipe_tmp;
    }
    {
      double fiss_size_val = cyclus::Query<double>(sub, "fiss_size");
      fiss_size = fiss_size_val;
    }
    if (sub->NMatches("topup_commod") > 0) {
      {
        std::string topup_commod_val = cyclus::Query<std::string>(sub, "topup_commod");
        topup_commod = topup_commod_val;
      }
    } else {
      std::string topup_commod_tmp("");
      topup_commod = topup_commod_tmp;
    }
    if (sub->NMatches("topup_pref") > 0) {
      {
        double topup_pref_val = cyclus::Query<double>(sub, "topup_pref");
        topup_pref = topup_pref_val;
      }
    } else {
      double topup_pref_tmp = 1.0;
      topup_pref = topup_pref_tmp;
    }
    if (sub->NMatches("topup_recipe") > 0) {
      {
        std::string topup_recipe_val = cyclus::Query<std::string>(sub, "topup_recipe");
        topup_recipe = topup_recipe_val;
      }
    } else {
      std::string topup_recipe_tmp("");
      topup_recipe = topup_recipe_tmp;
    }
    if (sub->NMatches("topup_size") > 0) {
      {
        double topup_size_val = cyclus::Query<double>(sub, "topup_size");
        topup_size = topup_size_val;
      }
    } else {
      double topup_size_tmp = 0;
      topup_size = topup_size_tmp;
    }
    {
      std::string outcommod_val = cyclus::Query<std::string>(sub, "outcommod");
      outcommod = outcommod_val;
    }
    if (sub->NMatches("throughput") > 0) {
      {
        double throughput_val = cyclus::Query<double>(sub, "throughput");
        throughput = throughput_val;
      }
    } else {
      double throughput_tmp = 1e+299;
      throughput = throughput_tmp;
    }
    {
      std::string spectrum_val = cyclus::Query<std::string>(sub, "spectrum");
      spectrum = spectrum_val;
    }
    if (sub->NMatches("latitude") > 0) {
      {
        double latitude_val = cyclus::Query<double>(sub, "latitude");
        latitude = latitude_val;
      }
    } else {
      double latitude_tmp = 0.0;
      latitude = latitude_tmp;
    }
    if (sub->NMatches("longitude") > 0) {
      {
        double longitude_val = cyclus::Query<double>(sub, "longitude");
        longitude = longitude_val;
      }
    } else {
      double longitude_tmp = 0.0;
      longitude = longitude_tmp;
    }
    di.NewDatum("Info")
    ->AddVal("fill_commods", fill_commods, &cycpp_shape_fill_commods)
    ->AddVal("fill_commod_prefs", fill_commod_prefs, &cycpp_shape_fill_commod_prefs)
    ->AddVal("fill_recipe", fill_recipe, &cycpp_shape_fill_recipe)
    ->AddVal("fill_size", fill_size, &cycpp_shape_fill_size)
    ->AddVal("fiss_commods", fiss_commods, &cycpp_shape_fiss_commods)
    ->AddVal("fiss_commod_prefs", fiss_commod_prefs, &cycpp_shape_fiss_commod_prefs)
    ->AddVal("fiss_recipe", fiss_recipe, &cycpp_shape_fiss_recipe)
    ->AddVal("fiss_size", fiss_size, &cycpp_shape_fiss_size)
    ->AddVal("topup_commod", topup_commod, &cycpp_shape_topup_commod)
    ->AddVal("topup_pref", topup_pref, &cycpp_shape_topup_pref)
    ->AddVal("topup_recipe", topup_recipe, &cycpp_shape_topup_recipe)
    ->AddVal("topup_size", topup_size, &cycpp_shape_topup_size)
    ->AddVal("outcommod", outcommod, &cycpp_shape_outcommod)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("spectrum", spectrum, &cycpp_shape_spectrum)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual cyclus::Agent* Clone() {
    cycamore::FuelFab* m = new cycamore::FuelFab(context());
    m->InitFrom(this);
    return m;
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"fill_commods\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"string\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"fill_commod_prefs\">\n"
      "            <oneOrMore>\n"
      "                <element name=\"val\">\n"
      "                    <data type=\"double\"/>\n"
      "                </element>\n"
      "            </oneOrMore>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"fill_recipe\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <element name=\"fill_size\">\n"
      "        <data type=\"double\"/>\n"
      "    </element>\n"
      "    <element name=\"fiss_commods\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"string\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"fiss_commod_prefs\">\n"
      "            <oneOrMore>\n"
      "                <element name=\"val\">\n"
      "                    <data type=\"double\"/>\n"
      "                </element>\n"
      "            </oneOrMore>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"fiss_recipe\">\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"fiss_size\">\n"
      "        <data type=\"double\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"topup_commod\">\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"topup_pref\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"topup_recipe\">\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"topup_size\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"outcommod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"throughput\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"spectrum\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"latitude\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"longitude\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "</interleave>\n";
  };
 
  virtual Json::Value annotations() {
    Json::Value root;
    Json::Reader reader;
    bool parsed_ok = reader.parse(
      "{\"name\":\"cycamore::FuelFab\",\"entity\":\"facility\",\"p"
      "arents\":[\"cyclus::Facility\",\"cyclus::toolkit::Posi"
      "tion\"],\"all_parents\":[\"cyclus::Agent\",\"cyclus::Fac"
      "ility\",\"cyclus::Ider\",\"cyclus::StateWrangler\",\"cyc"
      "lus::TimeListener\",\"cyclus::Trader\",\"cyclus::toolk"
      "it::Position\"],\"vars\":{\"fill_commods\":{\"doc\":\"Orde"
      "red list of commodities on which to requesting "
      "filler stream material.\",\"uilabel\":[\"Filler Stream"
      " Commodities\",\"\"],\"uitype\":[\"oneormore\",\"incommodi"
      "ty\"],\"type\":[\"std::vector\",\"std::string\"],\"index\":"
      "0,\"shape\":[-1,-"
      "1],\"alias\":[\"fill_commods\",\"val\"],\"tooltip\":[\"fill"
      "_commods\",\"\"]},\"fill_commod_prefs\":{\"default\":[],\""
      "uilabel\":[\"Filler Stream "
      "Preferences\",\"\"],\"doc\":\"Filler stream commodity "
      "request preferences for each of the given filler "
      "commodities (same order). If unspecified, default "
      "is to use 1.0 for all preferences.\",\"type\":[\"std::"
      "vector\",\"double\"],\"index\":1,\"shape\":[-1,-"
      "1],\"alias\":[\"fill_commod_prefs\",\"val\"],\"tooltip\":["
      "\"fill_commod_prefs\",\"\"]},\"fill_recipe\":{\"doc\":\"Nam"
      "e of recipe to be used in filler material stream "
      "requests.\",\"uilabel\":\"Filler Stream Recipe\",\"uityp"
      "e\":\"inrecipe\",\"type\":\"std::string\",\"index\":2,\"shap"
      "e\":[-"
      "1],\"alias\":\"fill_recipe\",\"tooltip\":\"fill_recipe\"},"
      "\"fill_size\":{\"doc\":\"Size of filler material stream"
      " inventory.\",\"uilabel\":\"Filler Stream Inventory Ca"
      "pacity\",\"units\":\"kg\",\"type\":\"double\",\"index\":3,\"sh"
      "ape\":[-"
      "1],\"alias\":\"fill_size\",\"tooltip\":\"fill_size\"},\"fil"
      "l\":{\"capacity\":\"fill_size\",\"type\":[\"cyclus::toolki"
      "t::ResBuf\",\"cyclus::Material\"],\"index\":4,\"shape\":["
      "-1,-1]},\"fiss_commods\":{\"doc\":\"Ordered list of "
      "commodities on which to requesting fissile stream "
      "material.\",\"uilabel\":[\"Fissile Stream Commodities\""
      ",\"\"],\"uitype\":[\"oneormore\",\"incommodity\"],\"type\":["
      "\"std::vector\",\"std::string\"],\"index\":5,\"shape\":[-"
      "1,-"
      "1],\"alias\":[\"fiss_commods\",\"val\"],\"tooltip\":[\"fiss"
      "_commods\",\"\"]},\"fiss_commod_prefs\":{\"default\":[],\""
      "uilabel\":[\"Fissile Stream "
      "Preferences\",\"\"],\"doc\":\"Fissile stream commodity "
      "request preferences for each of the given fissile "
      "commodities (same order). If unspecified, default "
      "is to use 1.0 for all preferences.\",\"type\":[\"std::"
      "vector\",\"double\"],\"index\":6,\"shape\":[-1,-"
      "1],\"alias\":[\"fiss_commod_prefs\",\"val\"],\"tooltip\":["
      "\"fiss_commod_prefs\",\"\"]},\"fiss_recipe\":{\"doc\":\"Nam"
      "e for recipe to be used in fissile stream "
      "requests. Empty string results in use of an empty "
      "dummy "
      "recipe.\",\"uitype\":\"inrecipe\",\"uilabel\":\"Fissile "
      "Stream Recipe\",\"default\":\"\",\"type\":\"std::string\",\""
      "index\":7,\"shape\":[-"
      "1],\"alias\":\"fiss_recipe\",\"tooltip\":\"fiss_recipe\"},"
      "\"fiss_size\":{\"doc\":\"Size of fissile material "
      "stream inventory.\",\"uilabel\":\"Fissile Stream "
      "Inventory Capacity\",\"units\":\"kg\",\"type\":\"double\",\""
      "index\":8,\"shape\":[-"
      "1],\"alias\":\"fiss_size\",\"tooltip\":\"fiss_size\"},\"fis"
      "s\":{\"capacity\":\"fiss_size\",\"type\":[\"cyclus::toolki"
      "t::ResBuf\",\"cyclus::Material\"],\"index\":9,\"shape\":["
      "-1,-1]},\"topup_commod\":{\"doc\":\"Commodity on which "
      "to request material for top-up stream. This MUST "
      "be set if 'topup_size > 0'.\",\"uilabel\":\"Top-up "
      "Stream Commodity\",\"default\":\"\",\"uitype\":\"incommodi"
      "ty\",\"type\":\"std::string\",\"index\":10,\"shape\":[-"
      "1],\"alias\":\"topup_commod\",\"tooltip\":\"topup_commod\""
      "},\"topup_pref\":{\"doc\":\"Top-up material stream "
      "request preference.\",\"uilabel\":\"Top-up Stream Pref"
      "erence\",\"default\":1.0,\"type\":\"double\",\"index\":11,\""
      "shape\":[-"
      "1],\"alias\":\"topup_pref\",\"tooltip\":\"topup_pref\"},\"t"
      "opup_recipe\":{\"doc\":\"Name of recipe to be used in "
      "top-up material stream requests. This MUST be set "
      "if 'topup_size > 0'.\",\"uilabel\":\"Top-up Stream Rec"
      "ipe\",\"uitype\":\"inrecipe\",\"default\":\"\",\"type\":\"std:"
      ":string\",\"index\":12,\"shape\":[-"
      "1],\"alias\":\"topup_recipe\",\"tooltip\":\"topup_recipe\""
      "},\"topup_size\":{\"doc\":\"Size of top-up material "
      "stream inventory.\",\"uilabel\":\"Top-up Stream "
      "Inventory Capacity\",\"units\":\"kg\",\"default\":0,\"type"
      "\":\"double\",\"index\":13,\"shape\":[-"
      "1],\"alias\":\"topup_size\",\"tooltip\":\"topup_size\"},\"t"
      "opup\":{\"capacity\":\"topup_size\",\"type\":[\"cyclus::to"
      "olkit::ResBuf\",\"cyclus::Material\"],\"index\":14,\"sha"
      "pe\":[-1,-1]},\"outcommod\":{\"doc\":\"Commodity on "
      "which to offer/supply mixed fuel "
      "material.\",\"uilabel\":\"Output Commodity\",\"uitype\":\""
      "outcommodity\",\"type\":\"std::string\",\"index\":15,\"sha"
      "pe\":[-"
      "1],\"alias\":\"outcommod\",\"tooltip\":\"outcommod\"},\"thr"
      "oughput\":{\"doc\":\"Maximum number of kg of fuel "
      "material that can be supplied per time "
      "step.\",\"uilabel\":\"Maximum Throughput\",\"units\":\"kg\""
      ",\"default\":1e+299,\"uitype\":\"range\",\"range\":[0.0,1e"
      "+299],\"type\":\"double\",\"index\":16,\"shape\":[-"
      "1],\"alias\":\"throughput\",\"tooltip\":\"throughput\"},\"s"
      "pectrum\":{\"uilabel\":\"Spectrum type\",\"uitype\":\"comb"
      "obox\",\"categorical\":[\"fission_spectrum_ave\",\"therm"
      "al\"],\"doc\":\"The type of cross-sections to use for "
      "composition property calculation. Use "
      "'fission_spectrum_ave' for fast reactor "
      "compositions or 'thermal' for thermal reactors.\",\""
      "type\":\"std::string\",\"index\":17,\"shape\":[-"
      "1],\"alias\":\"spectrum\",\"tooltip\":\"spectrum\"},\"latit"
      "ude\":{\"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.\",\"type"
      "\":\"double\",\"index\":18,\"shape\":[-"
      "1],\"alias\":\"latitude\",\"tooltip\":\"latitude\"},\"longi"
      "tude\":{\"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.\",\"type"
      "\":\"double\",\"index\":19,\"shape\":[-"
      "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"ni"
      "che\":\"fabrication\",\"doc\":\"FuelFab takes in 2 "
      "streams of material and mixes them in ratios in "
      "order to supply material that matches some "
      "neutronics properties of reqeusted material.  It "
      "uses an equivalence type method [1] inspired by a "
      "similar approach in the COSI fuel cycle "
      "simulator.\\n\\nThe FuelFab has 3 input inventories:"
      " fissile stream, filler stream, and an optional "
      "top-up inventory.  All materials received into "
      "each inventory are always combined into a single "
      "material (i.e. a single fissile material, a single"
      " filler material, etc.).  The input streams and "
      "requested fuel composition are each assigned "
      "weights based on summing:\\n\\n    N * (p_i - "
      "p_U238) / (p_Pu239 - p_U238)\\n\\nfor each nuclide "
      "where:\\n\\n    - p = nu*sigma_f - sigma_a   for the"
      " nuclide\\n    - p_U238 is p for pure U238\\n    - "
      "p_Pu239 is p for pure Pu239\\n    - N is the "
      "nuclide's atom fraction\\n    - nu is the average #"
      " neutrons per fission\\n    - sigma_f is the "
      "microscopic fission cross-section\\n    - sigma_a "
      "is the microscopic neutron absorption cross-"
      "section\\n\\nThe cross sections are from the simple "
      "cross section library in PyNE. They can be set to "
      "either a thermal or fast neutron spectrum.  A "
      "linear interpolation is performed using the "
      "weights of the fissile, filler, and target "
      "streams. The interpolation is used to compute a "
      "mixing ratio of the input streams that matches the"
      " target weight.  In the event that the target "
      "weight is higher than the fissile stream weight, "
      "the FuelFab will attempt to use the top-up and "
      "fissile input streams together instead of the "
      "fissile and filler streams.  All supplied material"
      " will always have the same weight as the requested"
      " material.\\n\\nThe supplying of mixed material is "
      "constrained by available inventory quantities and "
      "a per time step throughput limit.  Requests for "
      "fuel material larger than the throughput can never"
      " be met.  Fissile inventory can be "
      "requested/received via one or more commodities.  "
      "The DRE request preference for each of these "
      "commodities can also optionally be specified. By "
      "default, the top-up inventory size is zero, and it"
      " is not used for mixing. \\n\\n[1] Baker, A. R., and"
      " R. W. Ross. \\\"Comparison of the value of "
      "plutonium and    uranium isotopes in fast "
      "reactors.\\\" Proceedings of the Conference on    "
      "Breeding. Economics, and Safety in Large Fast "
      "Power Reactors. 1963.\"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::FuelFab.");
    }
    return root;
  };
 
  virtual void InitInv(cyclus::Inventories& inv) {
    fill.Push(inv["fill"]);
        fiss.Push(inv["fiss"]);
        topup.Push(inv["topup"]);
    
  };
 
  virtual cyclus::Inventories SnapshotInv() {
    cyclus::Inventories invs;
    invs["fill"] = fill.PopNRes(fill.count());
    fill.Push(invs["fill"]);
    invs["fiss"] = fiss.PopNRes(fiss.count());
    fiss.Push(invs["fiss"]);
    invs["topup"] = topup.PopNRes(topup.count());
    topup.Push(invs["topup"]);
    return invs;
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("fill_commods", fill_commods, &cycpp_shape_fill_commods)
    ->AddVal("fill_commod_prefs", fill_commod_prefs, &cycpp_shape_fill_commod_prefs)
    ->AddVal("fill_recipe", fill_recipe, &cycpp_shape_fill_recipe)
    ->AddVal("fill_size", fill_size, &cycpp_shape_fill_size)
    ->AddVal("fiss_commods", fiss_commods, &cycpp_shape_fiss_commods)
    ->AddVal("fiss_commod_prefs", fiss_commod_prefs, &cycpp_shape_fiss_commod_prefs)
    ->AddVal("fiss_recipe", fiss_recipe, &cycpp_shape_fiss_recipe)
    ->AddVal("fiss_size", fiss_size, &cycpp_shape_fiss_size)
    ->AddVal("topup_commod", topup_commod, &cycpp_shape_topup_commod)
    ->AddVal("topup_pref", topup_pref, &cycpp_shape_topup_pref)
    ->AddVal("topup_recipe", topup_recipe, &cycpp_shape_topup_recipe)
    ->AddVal("topup_size", topup_size, &cycpp_shape_topup_size)
    ->AddVal("outcommod", outcommod, &cycpp_shape_outcommod)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("spectrum", spectrum, &cycpp_shape_spectrum)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
#line 117 "/cycamore/src/fuel_fab.h"
 
  virtual void Tick(){};
  virtual void Tock(){};
  virtual void EnterNotify();
 
  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 AcceptMatlTrades(const std::vector<std::pair<
      cyclus::Trade<cyclus::Material>, cyclus::Material::Ptr> >& responses);
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
  GetMatlRequests();
 
 private:
  #pragma cyclus var {     "doc": "Ordered list of commodities on which to requesting filler stream material.",     "uilabel": "Filler Stream Commodities",     "uitype": ["oneormore", "incommodity"],   }
#line 142 "/cycamore/src/fuel_fab.h"
  std::vector<std::string> fill_commods;
  std::vector<int> cycpp_shape_fill_commods;
 
  #pragma cyclus var {     "default": [],     "uilabel": "Filler Stream Preferences",     "doc": "Filler stream commodity request preferences for each of the given filler commodities (same order)."            " If unspecified, default is to use 1.0 for all preferences.",   }
#line 149 "/cycamore/src/fuel_fab.h"
  std::vector<double> fill_commod_prefs;
  std::vector<int> cycpp_shape_fill_commod_prefs;
 
  #pragma cyclus var {     "doc": "Name of recipe to be used in filler material stream requests.",     "uilabel": "Filler Stream Recipe",     "uitype": "inrecipe",   }
#line 155 "/cycamore/src/fuel_fab.h"
  std::string fill_recipe;
  std::vector<int> cycpp_shape_fill_recipe;
 
  #pragma cyclus var {     "doc": "Size of filler material stream inventory.",     "uilabel": "Filler Stream Inventory Capacity",     "units": "kg",   }
#line 161 "/cycamore/src/fuel_fab.h"
  double fill_size;
  std::vector<int> cycpp_shape_fill_size;
 
#line 162 "/cycamore/src/fuel_fab.h"
  #pragma cyclus var {"capacity": "fill_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> fill;
  std::vector<int> cycpp_shape_fill;
#line 164 "/cycamore/src/fuel_fab.h"
 
 
  #pragma cyclus var {     "doc": "Ordered list of commodities on which to requesting fissile stream material.",     "uilabel": "Fissile Stream Commodities",     "uitype": ["oneormore", "incommodity"],   }
#line 170 "/cycamore/src/fuel_fab.h"
  std::vector<std::string> fiss_commods;
  std::vector<int> cycpp_shape_fiss_commods;
 
  #pragma cyclus var {     "default": [],     "uilabel": "Fissile Stream Preferences",     "doc": "Fissile stream commodity request preferences for each of the given fissile commodities (same order)."            " If unspecified, default is to use 1.0 for all preferences.",   }
#line 177 "/cycamore/src/fuel_fab.h"
  std::vector<double> fiss_commod_prefs;
  std::vector<int> cycpp_shape_fiss_commod_prefs;
 
  #pragma cyclus var {     "doc": "Name for recipe to be used in fissile stream requests."            " Empty string results in use of an empty dummy recipe.",     "uitype": "inrecipe",     "uilabel": "Fissile Stream Recipe",     "default": "",   }
#line 185 "/cycamore/src/fuel_fab.h"
  std::string fiss_recipe;
  std::vector<int> cycpp_shape_fiss_recipe;
 
  #pragma cyclus var {     "doc": "Size of fissile material stream inventory.",     "uilabel": "Fissile Stream Inventory Capacity",     "units": "kg",   }
#line 191 "/cycamore/src/fuel_fab.h"
  double fiss_size;
  std::vector<int> cycpp_shape_fiss_size;
 
#line 192 "/cycamore/src/fuel_fab.h"
  #pragma cyclus var {"capacity": "fiss_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> fiss;
  std::vector<int> cycpp_shape_fiss;
#line 194 "/cycamore/src/fuel_fab.h"
 
 
  #pragma cyclus var {     "doc": "Commodity on which to request material for top-up stream."            " This MUST be set if 'topup_size > 0'.",     "uilabel": "Top-up Stream Commodity",     "default": "",     "uitype": "incommodity",   }
#line 202 "/cycamore/src/fuel_fab.h"
  std::string topup_commod;
  std::vector<int> cycpp_shape_topup_commod;
#line 209 "/cycamore/src/fuel_fab.h"
 
  #pragma cyclus var {     "doc": "Top-up material stream request preference.",     "uilabel": "Top-up Stream Preference",     "default": 1.0,   }
  double topup_pref;
  std::vector<int> cycpp_shape_topup_pref;
 // default must be in range (0, cyclus::kDefaultPref)
 
  #pragma cyclus var {     "doc": "Name of recipe to be used in top-up material stream requests."            " This MUST be set if 'topup_size > 0'.",     "uilabel": "Top-up Stream Recipe",     "uitype": "inrecipe",     "default": "",   }
#line 217 "/cycamore/src/fuel_fab.h"
  std::string topup_recipe;
  std::vector<int> cycpp_shape_topup_recipe;
 
  #pragma cyclus var {     "doc": "Size of top-up material stream inventory.",     "uilabel": "Top-up Stream Inventory Capacity",     "units": "kg",     "default": 0,   }
#line 224 "/cycamore/src/fuel_fab.h"
  double topup_size;
  std::vector<int> cycpp_shape_topup_size;
 
#line 225 "/cycamore/src/fuel_fab.h"
  #pragma cyclus var {"capacity": "topup_size"}
  cyclus::toolkit::ResBuf<cyclus::Material> topup;
  std::vector<int> cycpp_shape_topup;
#line 227 "/cycamore/src/fuel_fab.h"
 
 
  #pragma cyclus var {     "doc": "Commodity on which to offer/supply mixed fuel material.",     "uilabel": "Output Commodity",     "uitype": "outcommodity",   }
#line 233 "/cycamore/src/fuel_fab.h"
  std::string outcommod;
  std::vector<int> cycpp_shape_outcommod;
#line 234 "/cycamore/src/fuel_fab.h"
 
 
  #pragma cyclus var {     "doc": "Maximum number of kg of fuel material that can be supplied per time step.",     "uilabel": "Maximum Throughput",     "units": "kg",     "default": CY_LARGE_DOUBLE,     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],   }
#line 243 "/cycamore/src/fuel_fab.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
#line 244 "/cycamore/src/fuel_fab.h"
 
 
  #pragma cyclus var {              "uilabel": "Spectrum type",     "uitype": "combobox",     "categorical": ["fission_spectrum_ave", "thermal"],     "doc": "The type of cross-sections to use for composition property calculation."            " Use 'fission_spectrum_ave' for fast reactor compositions or 'thermal' for thermal reactors.",   }
#line 252 "/cycamore/src/fuel_fab.h"
  std::string spectrum;
  std::vector<int> cycpp_shape_spectrum;
 
#line 253 "/cycamore/src/fuel_fab.h"
 
  // intra-time-step state - no need to be a state var
  // map<request, inventory name>
  std::map<cyclus::Request<cyclus::Material>*, std::string> req_inventories_;
 
  #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 264 "/cycamore/src/fuel_fab.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 265 "/cycamore/src/fuel_fab.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 272 "/cycamore/src/fuel_fab.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 273 "/cycamore/src/fuel_fab.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
 
double CosiWeight(cyclus::Composition::Ptr c, const std::string& spectrum);
bool ValidWeights(double w_low, double w_tgt, double w_high);
double LowFrac(double w_low, double w_tgt, double w_high, double eps = cyclus::CY_NEAR_ZERO);
double HighFrac(double w_low, double w_tgt, double w_high, double eps = cyclus::CY_NEAR_ZERO);
double AtomToMassFrac(double atomfrac, cyclus::Composition::Ptr c1, cyclus::Composition::Ptr c2);
 
} // namespace cycamore
 
 
#endif  // CYCAMORE_SRC_FUEL_FAB_H_