Merge pull request #639 from dean-krueger/code-injection

Clean Up Storage .h/.cc Files with Code Injection

Author: gonuke

CHANGELOG.rst

@@ -6,6 +6,7 @@ Since last release
 ======================
 
 **Added:**
+* Replaced manual matl_buy/sell_policy code in storage with code injection (#639)
 * Added package parameter to storage (#603, #612, #616)
 * Added package parameter to source (#613, #617, #621, #623, #630)
 * Added default keep packaging to reactor (#618, #619)

src/storage.cc

@@ -46,115 +46,6 @@ void Storage::InitFrom(cyclus::QueryableBackend* b) {
   cyclus::toolkit::CommodityProducer::SetCapacity(commod, throughput);
 }
 
-void Storage::InitBuyPolicyParameters() {
-  /// set up active buying distribution
-  if (active_buying_min > active_buying_max) {
-    throw cyclus::ValueError("Active min larger than max.");
-  }
-  if (dormant_buying_min > dormant_buying_max) {
-    throw cyclus::ValueError("Dormant min larger than max.");
-  }
-  if (buying_size_min > buying_size_max) {
-    throw cyclus::ValueError("Buying size min larger than max.");
-  }
-
-  if (active_buying_frequency_type == "Fixed") {
-    active_dist_ = cyclus::FixedIntDist::Ptr (new cyclus::FixedIntDist(active_buying_val));
-  }
-  else if (active_buying_frequency_type == "Uniform") {
-    if ((active_buying_min == -1) || (active_buying_max == -1)) {
-      throw cyclus::ValueError("Invalid active buying frequency range. Please provide both a min and max value.");
-    }
-    active_dist_ = cyclus::UniformIntDist::Ptr (new cyclus::UniformIntDist(active_buying_min, active_buying_max));
-  }
-  else if (active_buying_frequency_type == "Normal") {
-    if ((active_buying_mean == -1) || (active_buying_stddev == -1)) {
-      throw cyclus::ValueError("Invalid active buying frequency range. Please provide both a mean and standard deviation value.");
-    }
-    if (active_buying_min == -1) {active_buying_min = 1;}
-    if (active_buying_max == -1) {
-      active_buying_max = std::numeric_limits<int>::max();}
-
-    active_dist_ = cyclus::NormalIntDist::Ptr (new cyclus::NormalIntDist(active_buying_mean, active_buying_stddev,
-                          active_buying_min, active_buying_max));
-  }
-  else if (active_buying_frequency_type == "Binomial") {
-    if (active_buying_end_probability < 0 || active_buying_end_probability > 1) {
-      throw cyclus::ValueError("Active buying end probability must be between 0 and 1");
-    }
-    int success = 1; // only one success is needed to end the active buying period
-    active_dist_ = cyclus::NegativeBinomialIntDist::Ptr (new cyclus::NegativeBinomialIntDist(success, active_buying_end_probability));
-  } else if (active_buying_frequency_type == "FixedWithDisruption") {
-    if (active_buying_disruption < 0) {
-      throw cyclus::ValueError("Disruption must be greater than or equal to 0");
-    }
-    active_dist_ = cyclus::BinaryIntDist::Ptr (
-      new cyclus::BinaryIntDist(active_buying_disruption_probability,
-      active_buying_disruption, active_buying_val));
-  }
-  else {
-    throw cyclus::ValueError("Invalid active buying frequency type");}
-
-  /// set up dormant buying distribution
-  if (dormant_buying_frequency_type == "Fixed") {
-    dormant_dist_ = cyclus::FixedIntDist::Ptr (new cyclus::FixedIntDist(dormant_buying_val));
-  }
-  else if (dormant_buying_frequency_type == "Uniform") {
-    if ((dormant_buying_min == -1) || (dormant_buying_max == -1)) {
-      throw cyclus::ValueError("Invalid dormant buying frequency range. Please provide both a min and max value.");
-    }
-    dormant_dist_ = cyclus::UniformIntDist::Ptr (new cyclus::UniformIntDist(dormant_buying_min, dormant_buying_max));
-  }
-  else if (dormant_buying_frequency_type == "Normal") {
-    if ((dormant_buying_mean == -1) || (dormant_buying_stddev == -1)) {
-      throw cyclus::ValueError("Invalid dormant buying frequency range. Please provide both a mean and standard deviation value.");
-    }
-    if (dormant_buying_min == -1) {dormant_buying_min = 1;}
-    if (dormant_buying_max == -1) {
-      dormant_buying_max = std::numeric_limits<int>::max();}
-    dormant_dist_ = cyclus::NormalIntDist::Ptr (new cyclus::NormalIntDist(dormant_buying_mean, dormant_buying_stddev,
-                          dormant_buying_min, dormant_buying_max));
-  }
-  else if (dormant_buying_frequency_type == "Binomial") {
-    if (dormant_buying_end_probability < 0 || dormant_buying_end_probability > 1) {
-      throw cyclus::ValueError("Dormant buying end probability must be between 0 and 1");
-    }
-    int success = 1; // only one success is needed to end the dormant buying period
-    dormant_dist_ = cyclus::NegativeBinomialIntDist::Ptr (new cyclus::NegativeBinomialIntDist(success, dormant_buying_end_probability));
-  } else if (dormant_buying_frequency_type == "FixedWithDisruption") {
-    if (dormant_buying_disruption < 0) {
-      throw cyclus::ValueError("Disruption must be greater than or equal to 0");
-    }
-    dormant_dist_ = cyclus::BinaryIntDist::Ptr (
-      new cyclus::BinaryIntDist(dormant_buying_disruption_probability,
-      dormant_buying_disruption, dormant_buying_val));
-  }
-  else {
-    throw cyclus::ValueError("Invalid dormant buying frequency type");}
-
-  /// set up buying size distribution
-  if (buying_size_type == "Fixed") {
-    size_dist_ = cyclus::FixedDoubleDist::Ptr (new cyclus::FixedDoubleDist(buying_size_val));
-  }
-  else if (buying_size_type == "Uniform") {
-    if ((buying_size_min == -1) || (buying_size_max == -1)) {
-      throw cyclus::ValueError("Invalid buying size range. Please provide both a min and max value.");
-    }
-    size_dist_ = cyclus::UniformDoubleDist::Ptr (new cyclus::UniformDoubleDist(buying_size_min, buying_size_max));
-  }
-  else if (buying_size_type == "Normal") {
-    if ((buying_size_mean == -1) || (buying_size_stddev == -1)) {
-      throw cyclus::ValueError("Invalid buying size range. Please provide both a mean and standard deviation value.");
-    }
-    if (buying_size_min == -1) {buying_size_min = 0;}
-    if (buying_size_max == -1) {buying_size_max = 1;}
-    size_dist_ = cyclus::NormalDoubleDist::Ptr (new cyclus::NormalDoubleDist(buying_size_mean, buying_size_stddev,
-                             buying_size_min, buying_size_max));
-  }
-  else {
-    throw cyclus::ValueError("Invalid buying size type");}
-}
-
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 void Storage::EnterNotify() {
   cyclus::Facility::EnterNotify();