source: addons/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/Evaluators/MonolithicEvaluator.cs @ 17777

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using HeuristicLab.BioBoost.ProblemDescription;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.BioBoost.Data;
using HeuristicLab.BioBoost.Representation;
using HeuristicLab.BioBoost.Utils;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.PluginInfrastructure;
using HEAL.Attic;

namespace HeuristicLab.BioBoost.Evaluators {
  [StorableType("0C6D1BC1-3A29-4AA5-A7EB-724BFCA9FD55")]
  public class MonolithicEvaluator : AggregateEvaluator {

    #region ISingleObjectiveEvaluator Members
    public double Quality {
      get { return QualityParameter.ActualValue.Value; }
      set {  QualityParameter.ActualValue = new DoubleValue(value);}
    }
    #endregion

    #region IMultiObjectEvaluator Members
    private DoubleArray Qualities {
      get { return QualitiesParameter.ActualValue; }
      set {  QualitiesParameter.ActualValue = value;} }

    #endregion

    public IValueParameter<IntArray> QualityRoundingParameter { get { return (IValueParameter<IntArray>) Parameters["QualityRounding"]; } }
    public OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier> AlphaValueModifierParameter { get { return (OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>) Parameters["AlphaValueModifier"]; } }
    public IValueLookupParameter<DoubleValue> AlphaParameter { get { return (IValueLookupParameter<DoubleValue>) Parameters["Alpha"]; } }

    public IntArray QualityRounding { get { return QualityRoundingParameter.Value;  } }
    public IDiscreteDoubleValueModifier AlphaValueModifier { get { return AlphaValueModifierParameter.Value; } }
    public double Alpha { get { return AlphaParameter.ActualValue.Value; } }

    private static object simplificationLock = new object();

    #region Construction & Cloning
    [StorableConstructor]
    protected MonolithicEvaluator(StorableConstructorFlag _) : base(_) { }
    protected MonolithicEvaluator(MonolithicEvaluator orig, Cloner cloner) : base(orig, cloner) { }
    public MonolithicEvaluator() {
      Parameters.Add(new ValueParameter<IntArray>("QualityRounding", "The rounding cut-off for the quality (used e.g. for multi-object optimizaiton)."));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The weight of the first quality parameter", new DoubleValue(0.5)));
      Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("AlphaValueModifier", "An operator to modify the value of alpha over time",
        new ItemSet<IDiscreteDoubleValueModifier>( ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>())));
      foreach (var modifier in AlphaValueModifierParameter.ValidValues) {
        modifier.StartIndexParameter.Value = new IntValue(0);
        modifier.EndIndexParameter.ActualName = "MaximumGenerations";
        modifier.ValueParameter.ActualName = AlphaParameter.ActualName;
        modifier.IndexParameter.ActualName = "Generations";
        modifier.StartValueParameter.Value = new DoubleValue(1);
        modifier.EndValueParameter.Value = new DoubleValue(0.8);
      }
      // disable AggregateEvaluator heritage
      InitializeCostsAndIntermediateResults = false;
      OperatorGraph.InitialOperator = null;
      OperatorGraph.Operators.Clear();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MonolithicEvaluator(this, cloner);
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("QualityRounding"))
        Parameters.Add(new ValueParameter<IntArray>("QualityRounding", "The rounding cut-off for the quality (used e.g. for multi-object optimizaiton)."));
      if (!Parameters.ContainsKey("Alpha"))
        Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The weight of the first quality parameter", new DoubleValue(0.5)));
      if (!Parameters.ContainsKey("AlphaValueModifier")) {
        Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("AlphaValueModifier",
          "An operator to modify the value of alpha over time",
          new ItemSet<IDiscreteDoubleValueModifier>(
            ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>())));
        foreach (var modifier in AlphaValueModifierParameter.ValidValues) {
          modifier.StartIndexParameter.Value = new IntValue(0);
          modifier.EndIndexParameter.ActualName = "MaximumGenerations";
          modifier.ValueParameter.ActualName = AlphaParameter.ActualName;
          modifier.IndexParameter.ActualName = "Generations";
          modifier.StartValueParameter.Value = new DoubleValue(1);
          modifier.EndValueParameter.Value = new DoubleValue(0.8);
        }
      }
    }
    #endregion

    public override IOperation Apply() {
      var data = LoadOrCreateSimpleDataInScope();
      RealVector utilizations =
        GetFromScope<RealVector>(LayerDescriptor.Utilizations.NameWithPrefix(data.Echelons[0].FeedstockName));
      var temp = new Temp(data.N);
      temp.Amounts = CalculateFeedstockCosts(data, utilizations, temp);
      for (int i = 0; i < data.Echelons.Count - 1; i++) {
        IntegerVector transportTargets =
          GetFromScope<IntegerVector>(LayerDescriptor.TransportTargets.NameWithPrefix(data.Echelons[i].FeedstockName));
        temp.Amounts = CalculateLogisticCosts(data, i, temp, transportTargets);
        CalculateConversionCosts(data, i, temp);
      }
      var totalAmount = temp.Amounts.Sum();
      var maxPossibleAmount = data.Potentials.Sum();
      for (int i = 0; i < data.Echelons.Count - 1; i++)
        maxPossibleAmount *= data.Echelons[i].Conversion.MainProductConversionRate;
      //var nrOfPlants = temp.Amounts.Count(a => a > 0);
      var revenue = totalAmount*data.FinalProudctPrice;
      var roi = temp.TotalCost == 0 ? revenue : (revenue-temp.TotalCost)/temp.TotalCost;
      Quality = Alpha*(roi - temp.TotalPenalty) + (1-Alpha)*totalAmount/maxPossibleAmount;
      Qualities = new DoubleArray(new[] {Quality, totalAmount});
      //Qualities = new DoubleArray(new[] {Quality, Math.Log(nrOfPlants)/Math.Log(2)});
      if (QualityRoundingParameter.Value != null) {
        if (QualityRounding.Length > 0) {
          Quality = Math.Round(Quality, QualityRounding[0]);
          if (QualityRounding.Length >= Qualities.Length) {
            for (int i = 0; i < Qualities.Length; i++) {
              int precision = QualityRounding[i];
              if (precision >= 0) {
                Qualities[i] = Math.Round(Qualities[i], QualityRounding[i]);
              } else {
                var multiplier = Math.Pow(10, Math.Abs(precision));
                Qualities[i] = Math.Round(Qualities[i]/multiplier)*multiplier;
              }
            }
          }
        }
      }
      var ops = new OperationCollection();
      if (AlphaValueModifierParameter.ActualValue != null)
        ops.Add(ExecutionContext.CreateChildOperation(AlphaValueModifier));
      ops.Add(base.Apply());
      return ops;
    }

    private SimpleProblemData LoadOrCreateSimpleDataInScope() {
      var globalScope = ExecutionContext.Scope;
      while (globalScope.Parent != null)
        globalScope = globalScope.Parent;
      SimpleProblemData data;
      lock (simplificationLock) {
        IVariable dataVariable;
        if (!globalScope.Variables.TryGetValue("SimpleProblemData", out dataVariable) ||
            !(dataVariable.Value is SimpleProblemData) ||
             ((SimpleProblemData)dataVariable.Value).Echelons == null) {
          data = new SimpleProblemData(ProblemData);
          globalScope.Variables.Remove("SimpleProblemData");
          globalScope.Variables.Add(new Variable("SimpleProblemData", data));
        } else {
          data = dataVariable.Value as SimpleProblemData;
        }
      }
      return data;
    }

    private double[] CalculateFeedstockCosts(SimpleProblemData data, RealVector utilizations, Temp temp) {
      double cost = 0;
      var amountsAtSource = new double[data.N];
      for (int i = 0; i < data.N; i++) {
        var amount = data.Potentials[i]*utilizations[i];
        if (amount < 100) amount = 0; // TODO: make this configurable
        amountsAtSource[i] = amount;
        cost += FeedstockCostEvaluator.GetScaledCost(data.FeedstockBasePrices[i], data.FeedstockMaxPrices[i], amount, utilizations[i]);
      }
      temp.TotalCost += cost;
      return amountsAtSource;
    }

    private double[] CalculateLogisticCosts(SimpleProblemData data, int echelonNr, Temp temp, IntegerVector transportTargets) {
      var echelon = data.Echelons[echelonNr];
      var distanceMatrix = echelon.DistanceMatrix;
      var logistic = echelon.Logistic;
      double cost = 0;
      double penalty = 0;
      double[] amountsAtTarget = new double[data.N];
      for (int i = 0; i < data.N; i++) {
        if (temp.Amounts[i] <= 0) continue;
        var amount = Brace(temp.Amounts[i], logistic.MinAmount, logistic.MaxAmount);
        var target = transportTargets[i];
        amountsAtTarget[target] += Math.Min(temp.Amounts[i], amount); // cannot have more than before
        var distance = distanceMatrix[i, target];
        if (distance > logistic.MaxDistance)
          penalty += LogisticCostEvaluator.Penalty(distance, logistic.MaxDistance, distanceMatrix.Max);
        cost += data.GetLogisticActionCost(logistic.Transport, amount*distance*(1-logistic.WaterContent), i, target);
        cost += data.GetLogisticActionCost(logistic.Handling, amount*(1-logistic.WaterContent), i, target);
      }
      temp.TotalCost += cost;
      temp.TotalPenalty += penalty;
      return amountsAtTarget;
    }

    private static double Brace(double value, double min, double max) { return Math.Min(max, Math.Max(min, value)); }


    private void CalculateConversionCosts(SimpleProblemData data, int echelonNr, Temp temp) {
      var echelon = data.Echelons[echelonNr];
      var conversion = echelon.Conversion;
      double cost = 0;
      double penalty = 0;
      for (int i = 0; i < data.N; i++) {
        var amount = temp.Amounts[i];
        if (amount <= 0) continue;
        var maxCapacity = echelon.MaxConversionCapacities[i];
        amount = amount * (1-conversion.DryMatterLoss);
        var capacity = amount/conversion.UtilizationFactor;
        // NOTE: available capacities are ignored (unused anyway)
        var scale = capacity/conversion.DesignCapacity;
        var minScale = conversion.MinCapacity/conversion.DesignCapacity;
        var maxScale = maxCapacity/conversion.DesignCapacity;
        penalty += ConversionCostEvaluator.ScalingPenalty(scale, minScale, maxScale);
        penalty += ConversionCostEvaluator.CapacityPenalty(capacity, maxCapacity);
        cost += ConversionCostEvaluator.ScaledCost(scale, maxScale, conversion.Construction, conversion.ConstructionScalingExponent);
        cost += ConversionCostEvaluator.ScaledCost(scale, maxScale, conversion.Maintenance, conversion.MaintenanceScalingExponent);
        cost += conversion.Cost*amount; // side product costs and revenues have been factored in before
        var storageCapacity = capacity/365*conversion.SafetyStock;
        cost += data.GetLogisticActionCost(conversion.Storage, storageCapacity, i);
        temp.Amounts[i] = amount*conversion.MainProductConversionRate;
      }
      temp.TotalCost += cost;
      temp.TotalPenalty += penalty;
    }

    private T GetFromScope<T>(string variableName) where T: class{
      var variables = ExecutionContext.Scope.Variables;
      return variables[variableName].Value as T;
    }
  }

  public sealed class Temp {
    public double[] Amounts;
    public double TotalCost;
    public double TotalPenalty;
    public Temp(int n) { Amounts = new double[n]; }
  }

  [StorableType(StorableMemberSelection.AllFieldsAndAllProperties, "7BA4C277-AB0F-4A5F-A5B6-61E661104DCD")]
  public sealed class SimpleProblemData : Item {

    [StorableConstructor]
    private SimpleProblemData(StorableConstructorFlag _) : base(_) { }

    private SimpleProblemData(SimpleProblemData orig, Cloner cloner) : base(orig, cloner) {
      FinalProudctPrice = orig.FinalProudctPrice;
      N = orig.N;
      Potentials = Util.Clone(orig.Potentials);
      FeedstockBasePrices = Util.Clone(orig.FeedstockBasePrices);
      FeedstockMaxPrices = Util.Clone(orig.FeedstockMaxPrices);
      invest = Util.Clone(orig.invest);
      fuel = Util.Clone(orig.fuel);
      other = Util.Clone(orig.other);
      Echelons = orig.Echelons.Select(cloner.Clone).ToList();
    }

    public SimpleProblemData(BioBoostProblemData data) {
      N = data.LocationNames.Length;
      var feedstockName = data.Utilizations.CheckedItems.First().Value.Value;
      Potentials = ((IValueParameter<DoubleArray>) data.FeedstockPotentials[LayerDescriptor.PotentialsFromProblemData.NameWithPrefix(feedstockName)]).Value.ToArray();
      var feedstock = data.Products.First(p => p.Label == feedstockName);
      FeedstockBasePrices = data.LocationNames.Select(loc => feedstock.GetRegionalBasePrice(loc)).ToArray();
      FeedstockMaxPrices = data.LocationNames.Select(loc => feedstock.GetRegionalMaxPrice(loc)).ToArray();
      invest = data.InvestmentCostFactors.ToArray();
      maint = data.MaintenanceCostFactors.ToArray();
      fuel = data.FuelCostFactors.ToArray();
      labor = data.LaborCostFactors.ToArray();
      other = data.OtherCostFactors.ToArray();
      var transportedProducts = data.TransportTargets.CheckedItems.Select(i => i.Value.Value).ToArray();
      var prices = data.Products.ToDictionary(p => p.Label, p => p.Price);
        // different prices (@source/@target) are not considered (unused anyway)
      Echelons = new List<Echelon>(3);
      for (int i = 0; i < transportedProducts.Length; i++) {
        var echelon = new Echelon();
        var productName = echelon.FeedstockName = transportedProducts[i];
        var logistic = echelon.Logistic = (Logistic) data.Logistics[productName].First().Clone(); // TODO: make better choice
        logistic.Transport.Other += logistic.Transport.Emissions.TotalCost(prices, null);
        logistic.Handling.Other += logistic.Handling.Emissions.TotalCost(prices, null);
        echelon.DistanceMatrix = GetFromProblemData<DistanceMatrix>(data, logistic.Distances + "DistanceMatrix");
        var conversion = echelon.Conversion = (Conversion) data.Conversions[productName].First().Clone(); // TODO: make better choice?
        echelon.MaxConversionCapacities =
          data.LocationNames.Select(loc => ConversionCostEvaluator.GetMaxCapacity(conversion, loc)).ToArray();
        conversion.MaybeInferMainProduct(prices);
        conversion.Cost += conversion.Products.TotalCost(prices, conversion.MainProduct);
        Echelons.Add(echelon);
      }
      var finalEchelon = new Echelon();
      var finalProductName = finalEchelon.FeedstockName = data.FinalProducts.CheckedItems.First().Value.Value;
      Echelons.Add(finalEchelon);
      FinalProudctPrice = prices[finalProductName];
    }

    private static V GetValue<K,V>(IDictionary<K,V> d, K key, V defaultValue) {
      V value;
      if (d.TryGetValue(key, out value))
        return value;
      return defaultValue;
    }

    private static double GetValue(ValueParameterCollection parameters, string name, double defaultValue) {
      IValueParameter param = null;
      if (!parameters.TryGetValue(name, out param)) return defaultValue;
      var doubleValueParam = param as IValueLookupParameter<DoubleValue>;
      if (doubleValueParam == null) return defaultValue;
      return doubleValueParam.Value.Value;
    }

    [StorableType(StorableMemberSelection.AllFieldsAndAllProperties, "3AE651E8-E056-47A5-9ADA-AE8FD3F8063F")]
    public sealed class Echelon : Item {

      public Logistic Logistic;
      public DistanceMatrix DistanceMatrix;
      public double[] MaxConversionCapacities;
      public Conversion Conversion;
      public string FeedstockName;

      [StorableConstructor]
      private Echelon(StorableConstructorFlag _) : base(_) { }

      public Echelon() { }

      private Echelon(Echelon orig, Cloner cloner) {
        Logistic = cloner.Clone(orig.Logistic);
        DistanceMatrix = cloner.Clone(orig.DistanceMatrix);
        MaxConversionCapacities = Util.Clone(orig.MaxConversionCapacities);
        Conversion = cloner.Clone(orig.Conversion);
        FeedstockName = Util.Clone(orig.FeedstockName);
      }

      public override IDeepCloneable Clone(Cloner cloner) {
        return new Echelon(this, cloner);
      }
    }

    public double FinalProudctPrice;
    public int N;
    public double[] Potentials;
    public double[] FeedstockBasePrices;
    public double[] FeedstockMaxPrices;
    public double[] invest, maint, fuel, labor, other;
    public List<Echelon> Echelons; // nr of echelons + 1 for final product

    public double GetLogisticActionCost(LogisticAction a, double amount, int i, int j) {
      return 
        amount * (
          a.Investment  *(invest[i] + invest[j]) +
          a.Maintenance *( maint[i] +  maint[j]) +
          a.Fuel        *(  fuel[i] +   fuel[j]) +
          a.Labor       *( labor[i] +  labor[j]) +
          a.Other       *( other[i] +  other[j]))/2;
    }

    public double GetLogisticActionCost(LogisticAction a, double amount, int i) {
      return
        amount * (
          a.Investment  * invest[i] +
          a.Maintenance *  maint[i] +
          a.Fuel        *   fuel[i] +
          a.Labor       *  labor[i] +
          a.Other       *  other[i]);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new SimpleProblemData(this, cloner);
    }

    public static  T GetFromProblemData<T>(BioBoostProblemData data, string label) where T : class, IItem {
      IParameter param;
      data.Parameters.TryGetValue(label, out param);
      var valueParam = param as IValueParameter;
      if (valueParam != null) return valueParam.Value as T;
      if (param != null) return param.ActualValue as T;
      return null;
    }

  }
}