total_inv_tracker.h

Go to the documentation of this file.

#ifndef CYCLUS_SRC_TOOLKIT_TOTAL_INV_TRACKER_H_
#define CYCLUS_SRC_TOOLKIT_TOTAL_INV_TRACKER_H_
 
#include "error.h"
#include "res_buf.h"
 
namespace cyclus {
namespace toolkit {
 
/// TotalInvTracker is a helper class that tracks the total inventory of
/// multiple ResBufs. This can be useful when a single agent uses multiple
/// buffers to manage their process, but a limit should be placed on their
/// combined  inventory, such as a agent- or facility-wide maximum inventory.
/// Like  ResBufs, TotalInvTracker has an infinite capacity unless explicitly
/// changed.
///
/// TotalInvTracker does not hold any inventory itself, it only tracks the
/// quantities of other ResBufs. TotalInvTracker currently tracks quantities
/// alone, not compositions.
///
/// @code
/// class MyAgent : public cyclus:: Facility {
///   public:
///     EnterNotify() {
///       cyclus::Facility::EnterNotify();
///       tracker_.Init({&inventory_, &outventory_}, facility_max_inv_size_);
///
///       cyclus::MatlBuyPolicy p;
///       p.Init(this, &inventory_, "inventory", &tracker_);
/// }
///   protected:
///     cyclus::toolkit::ResBuf<cyclus::Material> inventory_;
///     cyclus::toolkit::ResBuf<cyclus::Material> outventory_;
///
///     double facility_max_inv_size_ = 1000;
///     cyclus::toolkit::TotalInvTracker tracker_;
/// }
 
class TotalInvTracker {
 public:
  /// Creates an uninitialized tracker. The Init function MUST be called before
  /// the tracker is used.
  TotalInvTracker()
      : max_inv_size_(std::numeric_limits<double>::max()), qty_(0){};
 
  TotalInvTracker(std::vector<ResBuf<Material>*> bufs,
                  double max_inv_size = std::numeric_limits<double>::max()) {
    Init(bufs, max_inv_size);
  }
 
  ~TotalInvTracker(){};
 
  /// Initializes the tracker with the given ResBufs. The tracker will have
  /// infinite capacity unless explicitly changed.
  void Init(std::vector<ResBuf<Material>*> bufs,
            double max_inv_size = std::numeric_limits<double>::max()) {
    if (bufs.size() == 0) {
      throw ValueError(
          "TotalInvTracker must be initialized with at least one ResBuf");
    }
    bufs_ = bufs;
    if (max_inv_size <= 0) {
      throw ValueError(
          "TotalInvTracker must be initialized with a positive capacity");
    }
    max_inv_size_ = max_inv_size;
  }
 
  /// Returns the total quantity of all tracked ResBufs.
  /// @throws ValueError if the tracker has not been initialized (zero)
  inline double quantity() {
    int num = num_bufs();
    qty_ = 0;
    for (int i = 0; i < num; i++) {
      qty_ += bufs_[i]->quantity();
    }
    return qty_;
  }
 
  /// Returns the total capacity that could go in the ResBufs. Either the
  /// capacity of the TotalInvTracker, or the sum of each ResBuf's capacity,
  /// whichever is lower.
  inline double capacity() {
    return std::min(total_capacity_bufs(), max_inv_size_);
  }
 
  // Returns the sum of the capacities of all buffers. Does not include the
  // capacity of the tracker
  inline double total_capacity_bufs() {
    int num = num_bufs();
    double cap = 0;
    for (int i = 0; i < num; i++) {
      cap += bufs_[i]->capacity();
    }
    return cap;
  }
 
  /// Returns the total capacity of the traker. Does not include ResBufs
  inline double tracker_capacity() { return max_inv_size_; }
 
  /// Returns the remaining facility-wide space across all tracked ResBufs.
  inline double space() { return std::max(0.0, capacity() - quantity()); }
 
  /// Returns the remaining space in the given ResBuf, considering the
  /// facility-wide limitations.
  inline double constrained_buf_space(ResBuf<Material>* buf) {
    return std::min(buf->space(), space());
  }
 
  /// Returns true if there are no resources in any buffer
  inline bool empty() { return quantity() == 0; }
 
  /// Returns number of buffers being tracked
  /// @throws ValueError if the tracker has not been initialized (zero)
  inline int num_bufs() {
    int num = bufs_.size();
    if (num == 0) {
      throw ValueError(
          "TotalInvTracker has not been initialized, no buffers to track");
    }
    return num;
  }
 
  /// Change the total capacity across all ResBufs. The new capacity must be
  /// greater than the current quantity.
  /// @throws ValueError if the new capacity is less than the current quantity
  void set_capacity(double cap) {
    if (quantity() - cap > eps_rsrc()) {
      std::stringstream ss;
      ss << std::setprecision(17) << "new capacity " << cap
         << " lower than existing quantity " << quantity();
      throw ValueError(ss.str());
    }
    max_inv_size_ = cap;
  }
 
  bool buf_in_tracker(ResBuf<Material>* buf) {
    for (int i = 0; i < num_bufs(); i++) {
      if (bufs_[i] == buf) {
        return true;
      }
    }
    return false;
  }
 
 private:
  double max_inv_size_;
  double qty_;
  std::vector<ResBuf<Material>*> bufs_;
};
 
}  // namespace toolkit
}  // namespace cyclus
 
#endif  // CYCLUS_SRC_TOOLKIT_TOTAL_INV_TRACKER_H_