greedy_preconditioner.cc

Go to the documentation of this file.

#include "greedy_preconditioner.h"

#include <algorithm>
#include <assert.h>
#include <numeric>
#include <string>

#include <boost/lambda/bind.hpp>

#include "cyc_std.h"
#include "logger.h"

namespace l = boost::lambda;

namespace cyclus {

inline double SumPref(double total, std::pair<Arc, double> pref) {
  return total += pref.second;
}

double AvgPref(ExchangeNode::Ptr n) {
  std::map<Arc, double>& prefs = n->prefs;
  return prefs.size() > 0 ?
      std::accumulate(prefs.begin(), prefs.end(), 0.0, SumPref) / prefs.size() :
      0;
}

GreedyPreconditioner::GreedyPreconditioner() {};

GreedyPreconditioner::GreedyPreconditioner(
    const std::map<std::string, double>& commod_weights)
    : commod_weights_(commod_weights) {
  if (commod_weights_.size() != 0)
    ProcessWeights_(END);
};

GreedyPreconditioner::GreedyPreconditioner(
    const std::map<std::string, double>& commod_weights,
    WgtOrder order)
    : commod_weights_(commod_weights) {
  if (commod_weights_.size() != 0)
    ProcessWeights_(order);
};

void GreedyPreconditioner::Condition(ExchangeGraph* graph) {
  avg_prefs_.clear();

  std::vector<RequestGroup::Ptr>& groups =
      const_cast<std::vector<RequestGroup::Ptr>&>(graph->request_groups());

  std::vector<RequestGroup::Ptr>::iterator it;
  for (it = groups.begin(); it != groups.end(); ++it) {
    std::vector<ExchangeNode::Ptr>& nodes =
        const_cast<std::vector<ExchangeNode::Ptr>&>((*it)->nodes());

    // get avg prefs
    for (int i = 0; i != nodes.size(); i++) {
      avg_prefs_[nodes[i]] = AvgPref(nodes[i]);
    }

    // sort nodes by weight
    std::stable_sort(
        nodes.begin(), nodes.end(),
        l::bind(&GreedyPreconditioner::NodeComp, this, l::_1, l::_2));

    // get avg group weights
    group_weights_[*it] = GroupWeight(*it, &commod_weights_, &avg_prefs_);
    CLOG(LEV_DEBUG1) << "Group weight value during graph preconditioning is "
                     << group_weights_[*it] << ".";
  }

  // sort groups by avg weight
  std::stable_sort(
      groups.begin(), groups.end(),
      l::bind(&GreedyPreconditioner::GroupComp, this, l::_1, l::_2));

  // clear graph-specific state
  group_weights_.clear();
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void GreedyPreconditioner::ProcessWeights_(WgtOrder order) {
  double min = std::min_element(
      commod_weights_.begin(),
      commod_weights_.end(),
      SecondLT< std::pair<std::string, double> >())->second;

  double max = std::max_element(
      commod_weights_.begin(),
      commod_weights_.end(),
      SecondLT< std::pair<std::string, double> >())->second;

  assert(commod_weights_.size() == 0 || min >= 0);

  std::map<std::string, double>::iterator it;
  switch (order) {
    case REVERSE:
      for (it = commod_weights_.begin();
           it != commod_weights_.end();
           ++it) {
        it->second = max + min - it->second;  // reverses order
      }
      break;
    default:  // do nothing
      break;
  }

  for (it = commod_weights_.begin();
       it != commod_weights_.end();
       ++it) {
    CLOG(LEV_INFO1) << "GreedyPreconditioner commodity weight value for "
                    << it->first
                    << " is " << it->second;
  }
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
double GroupWeight(RequestGroup::Ptr g,
                   std::map<std::string, double>* weights,
                   std::map<ExchangeNode::Ptr, double>* avg_prefs) {
  std::vector<ExchangeNode::Ptr>& nodes = g->nodes();
  double sum = 0;

  ExchangeNode::Ptr n;
  for (int i = 0; i != nodes.size(); i++) {
    n = nodes[i];
    sum += NodeWeight(n, weights, (*avg_prefs)[n]);
  }
  return nodes.size() > 0 ? sum / nodes.size() : 0;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
double NodeWeight(ExchangeNode::Ptr n,
                  std::map<std::string, double>* weights,
                  double avg_pref) {
  double commod_weight = (weights->size() != 0) ? (*weights)[n->commod] : 1;
  double node_weight = commod_weight * (1 + avg_pref / (1 + avg_pref));

  CLOG(LEV_DEBUG5) << "Determining node weight: ";
  CLOG(LEV_DEBUG5) << "       commodity weight: " << commod_weight;
  CLOG(LEV_DEBUG5) << "               avg pref: " << avg_pref;
  CLOG(LEV_DEBUG5) << "            node weight: " << node_weight;

  return node_weight;
}

}  // namespace cyclus