source: branches/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/Evaluators/ConversionCostEvaluator.cs @ 13069

using System.Drawing;
using HeuristicLab.BioBoost.Data;
using HeuristicLab.BioBoost.Utils;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.BioBoost.Representation;

namespace HeuristicLab.BioBoost.Evaluators {
  [StorableClass]
  [Item("ConversionCostEvaluator", "Simulates the conversion of all applicable conversion processes.")]
  public class ConversionCostEvaluator : BioBoostEvaluator {

    #region fields
    private DoubleArray invest, maint, fuel, labor, other;
    #endregion

    #region Construction & Cloning
    [StorableConstructor]
    protected ConversionCostEvaluator(bool isDeserializing) : base(isDeserializing) {}
    protected ConversionCostEvaluator(ConversionCostEvaluator original, Cloner cloner) : base(original, cloner) { }
    public ConversionCostEvaluator() { }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ConversionCostEvaluator(this, cloner);
    }
    #endregion

    public override IOperation Apply() {
      var conversions = ProblemData.Conversions;
      var products = new Dictionary<string, DoubleArray>();
      var prices = ProblemData.Products.ToDictionary(p => p.Label, p => p.Price);
      DoubleArray productCosts = new DoubleArray(0);
      invest = ProblemData.InvestmentCostFactors;
      maint = ProblemData.MaintenanceCostFactors;
      fuel = ProblemData.FuelCostFactors;
      labor = ProblemData.LaborCostFactors;
      other = ProblemData.OtherCostFactors;
      foreach (var feedstock in conversions.Select(c => c.Key)) {
        var feedstockAmounts = GetFromScope<DoubleArray>(LayerDescriptor.AmountsAtTarget.NameWithPrefix(feedstock));
        var feedstockCosts = GetFromScope<DoubleArray>(LayerDescriptor.TotalCostsAtTarget.NameWithPrefix(feedstock));
        if (feedstockAmounts == null) continue;
        var length = feedstockAmounts.Length;
        var totalConversionCost = 0d;
        var totalConstructionCost = 0d;
        var totalOperationCost = 0d;
        var totalStorageCost = 0d;
        var totalScalingPenalty = 0d;
        var totalExceedingCapacityPenalty = 0d;
        var converterCapacities = new DoubleArray(length);
        var maxCapacities = new DoubleArray(length);
        var storageCapacities = new DoubleArray(length);
        var chosenConversions = new List<Variant>(new Variant[length]);
        if (productCosts.Length < length)
          productCosts = new DoubleArray(length);
        for (int i = 0; i < length; i++) {
          var amount = feedstockAmounts[i];
          maxCapacities[i] = conversions[feedstock].Max(c => GetMaxCapacity(c, ProblemData.LocationNames[i]));
          if (amount <= 0) continue;
          var chosenConversion = ChooseConversion(conversions[feedstock], amount, i);
          if (chosenConversion != null) {
            //feedstockAmounts[i] = 0;
            totalConversionCost += chosenConversion.Cost;
            totalConstructionCost += chosenConversion.ConstructionCost;
            totalOperationCost += chosenConversion.OperationCost;
            totalStorageCost += chosenConversion.StorageCost;
            totalScalingPenalty += chosenConversion.ScalingPenalty;
            totalExceedingCapacityPenalty += chosenConversion.ExceedingCapacityPenalty;
            converterCapacities[i] = chosenConversion.Capacity;
            storageCapacities[i] = chosenConversion.StorageCapacity;
            AddProducts(products, chosenConversion.Conversion.Products, Math.Min(chosenConversion.Amount, chosenConversion.Capacity), i, length);
            AddProducts(products, chosenConversion.Conversion.ConstructionEmissions, chosenConversion.Capacity/chosenConversion.Conversion.DesignCapacity, i, length);
            chosenConversions[i] = chosenConversion;
            feedstockCosts[i] += chosenConversion.StorageCost;
            productCosts[i] += feedstockCosts[i] + chosenConversion.Cost + chosenConversion.ConstructionCost + chosenConversion.OperationCost; // still without side products
          } else {
            feedstockAmounts[i] = 0;
          }
        }
        // TODO: 2. Runde?!?!?
        //RemoveFromScope(LayerDescriptor.AmountsAtTarget.NameWithPrefix(feedstock));
        RenameInScope(LayerDescriptor.AmountsAtTarget.NameWithPrefix(feedstock), LayerDescriptor.AmountsAtTargetConverted.NameWithPrefix(feedstock));
        var conversionCosts = chosenConversions.Select(0, v => v.Cost).ToDoubleArray();
        var constructionCosts = chosenConversions.Select(0, v => v.ConstructionCost).ToDoubleArray();
        var operationCosts = chosenConversions.Select(0, v => v.OperationCost).ToDoubleArray();
        PutInScope(LayerDescriptor.ConversionCosts.NameWithPrefix(feedstock), conversionCosts, false);
        PutInScope(LayerDescriptor.ConversionPlantConstructionCost.NameWithPrefix(feedstock), constructionCosts, false);
        PutInScope(LayerDescriptor.ConversionPlantOperationCost.NameWithPrefix(feedstock), operationCosts, false);
        PutInScope(LayerDescriptor.RelativeConversionCosts.NameWithPrefix(feedstock), conversionCosts.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        PutInScope(LayerDescriptor.RelativeConversionPlantConstructionCosts.NameWithPrefix(feedstock), constructionCosts.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        PutInScope(LayerDescriptor.RelativeConversionPlantOperationCosts.NameWithPrefix(feedstock), operationCosts.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        var storageCosts = chosenConversions.Select(0, v => v.StorageCost).ToDoubleArray();
        PutInScope(LayerDescriptor.StorageCost.NameWithPrefix(feedstock), storageCosts, false);
        PutInScope(LayerDescriptor.RelativeStorageCost.NameWithPrefix(feedstock), storageCosts.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        var totalLogisticCost = GetFromScope<DoubleArray>(LayerDescriptor.TotalLogisticCosts.NameWithPrefix(feedstock));
        totalLogisticCost = totalLogisticCost.Zip(storageCosts, (l, s) => l + s).ToDoubleArray();
        PutInScope(LayerDescriptor.TotalLogisticCosts.NameWithPrefix(feedstock), totalLogisticCost, false);
        PutInScope(LayerDescriptor.LogisticCostsPerTon.NameWithPrefix(feedstock), totalLogisticCost.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        PutInScope(LayerDescriptor.MaxConversionCapacity.NameWithPrefix(feedstock), maxCapacities, false);
        var scalingPenalties = chosenConversions.Select(0, v => v.ScalingPenalty).ToDoubleArray();
        var exceedingCapacityPenalties = chosenConversions.Select(0, v => v.ExceedingCapacityPenalty).ToDoubleArray();
        PutInScope(LayerDescriptor.ScalingPenalty.NameWithPrefix(feedstock), scalingPenalties, false);
        PutInScope(LayerDescriptor.ExceedingCapacityPenalties.NameWithPrefix(feedstock), exceedingCapacityPenalties, false);
        AddInScope(LayerDescriptor.TotalPenalty.Name, scalingPenalties.Zip(exceedingCapacityPenalties, (s, c) => s+c).ToDoubleArray(), false);
        PutInScope(LayerDescriptor.TotalCostsAtTarget.NameWithPrefix(feedstock), feedstockCosts, false); // now including storage costs
        PutInScope(LayerDescriptor.RelativeCostAtTarget.NameWithPrefix(feedstock), feedstockCosts.Zip(feedstockAmounts, (c,a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        var totalDirectConversionCost = chosenConversions.Select(0, c => c.Cost + c.Conversion.Products.TotalCost(prices, c.Conversion.MainProduct)*c.Amount) .ToDoubleArray();
        PutInScope(LayerDescriptor.TotalDirectConversionCost.NameWithPrefix(feedstock), totalDirectConversionCost, false);
        //var mainProductAmounts = chosenConversions.Select((c, i) => c != null ? 0 : products[c.Conversion.MainProduct][i]).ToArray();
        PutInScope(LayerDescriptor.RelativeTotalDirectConversionCost.NameWithPrefix(feedstock), totalDirectConversionCost.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        PutInScope(LayerDescriptor.ScalingFactors.NameWithPrefix(feedstock), chosenConversions.Select(0, v => v.ScalingFactor).ToDoubleArray(), false);
        var totalAmortizedConversionCost = totalDirectConversionCost
          // .Zip(storageCosts, (t, s) => t + s) -> included in logistic costs
          .Zip(constructionCosts, (t, c) => t + c)
          .Zip(operationCosts, (t, o) => t + o)
          .ToDoubleArray();
        PutInScope(LayerDescriptor.TotalAmortizedConversionCosts.NameWithPrefix(feedstock), totalAmortizedConversionCost, false); 
        PutInScope(LayerDescriptor.RelativeTotalAmortizedConversionCosts.NameWithPrefix(feedstock), totalAmortizedConversionCost.Zip(feedstockAmounts, (c, a) => a == 0 ? 0 : c/a).ToDoubleArray(), false); 
        AddCost(LayerDescriptor.ConversionCosts.NameWithPrefix(feedstock), totalConversionCost);
        AddCost(LayerDescriptor.ConversionPlantConstructionCost.NameWithPrefix(feedstock), totalConstructionCost);
        AddCost(LayerDescriptor.ConversionPlantOperationCost.NameWithPrefix(feedstock), totalOperationCost);
        AddCost(LayerDescriptor.StorageCost.NameWithPrefix(feedstock), totalStorageCost);
        AddCost(LayerDescriptor.ScalingPenalty.NameWithPrefix(feedstock), totalScalingPenalty);
        AddCost(LayerDescriptor.ExceedingCapacityPenalties.NameWithPrefix(feedstock), totalExceedingCapacityPenalty);
        AddInScope(LayerDescriptor.ConverterCapacities.NameWithPrefix(feedstock), converterCapacities, false);
        AddInScope(LayerDescriptor.StorageCapacities.NameWithPrefix(feedstock), storageCapacities, false);
        AddInScope(LayerDescriptor.LocalAddedValue.Name, chosenConversions.Select(0, v => v.Cost + v.ConstructionCost + v.OperationCost).ToDoubleArray(), false);
        foreach (var p in products) {
          if (p.Value.Max() <= 0 || (prices.ContainsKey(p.Key) && prices[p.Key] <= 0)) continue; // don't report "production cost" for demands and waste products
          var costsAtSource = new DoubleArray(productCosts.Select((c,i) => c + (chosenConversions[i] == null ? 0 : chosenConversions[i].Conversion.Products.TotalCost(prices, p.Key)*chosenConversions[i].Amount)).ToArray());
          AddInScope(LayerDescriptor.TotalCostsAtSource.NameWithPrefix(p.Key), costsAtSource, false);
          costsAtSource = GetFromScope<DoubleArray>(LayerDescriptor.TotalCostsAtSource.NameWithPrefix(p.Key));
          PutInScope(LayerDescriptor.RelativeCostAtSource.NameWithPrefix(p.Key), costsAtSource.Zip(p.Value, (c,a) => a == 0 ? 0 : c/a).ToDoubleArray(), false);
        }
      }
      foreach (var p in products) {
        AddInScope(LayerDescriptor.AmountsAtSource.NameWithPrefix(p.Key), p.Value, false);
      }
      return base.Apply();
    }

    private void AddProducts(Dictionary<string, DoubleArray> overallProducts, IEnumerable<IValueParameter> products, double amount, int i, int length) {
      foreach (var e in products) {
        DoubleArray values = null;
        if (!overallProducts.TryGetValue(e.Name, out values)) {
          overallProducts.Add(e.Name, values = new DoubleArray(length));
        }
        values[i] += ((DoubleValue)e.Value).Value*amount;
      }
    }

    private class Variant : IComparable<Variant> {
      public Conversion Conversion;
      public double Cost;
      public double ConstructionCost;
      public double OperationCost;
      public double Capacity;
      public double StorageCost;
      public double StorageCapacity;
      public double Amount;
      public double ScalingPenalty;
      public double ExceedingCapacityPenalty;
      public double ScalingFactor;

      public int CompareTo(Variant other) {
        return (int) (Cost - other.Cost);
      }
    }

    private Variant ChooseConversion(IEnumerable<Conversion> conversions, double amount, int i) {
      var variants = new List<Variant>();
      foreach (var c in conversions) { // TODO: select best scaling variant?
        if (amount <= 0) continue;
        var actualAmount = amount * (1-c.DryMatterLoss);
        var v = new Variant {Capacity = actualAmount/c.UtilizationFactor, Conversion = c};
        var regionName = ProblemData.LocationNames[i];
        double maxCapacity = GetMaxCapacity(c, regionName);
        v.ExceedingCapacityPenalty = CapacityPenalty(v.Capacity, maxCapacity);
        //if (maxCapacity <= 0) continue;
        var availableCapacity = GetValue(c.AvailableCapacities, regionName, 0);
        var newCapacity = Math.Max(0, v.Capacity - availableCapacity);
        v.ScalingFactor = v.Capacity/c.DesignCapacity;
        var minScale = c.MinCapacity/c.DesignCapacity;
        var maxScale = maxCapacity/c.DesignCapacity;
        v.ScalingPenalty = ScalingPenalty(v.ScalingFactor, minScale, maxScale);
        v.ConstructionCost = ScaledCost(newCapacity/c.DesignCapacity, maxScale, c.Construction, c.ConstructionScalingExponent);
        v.OperationCost = ScaledCost(v.ScalingFactor, maxScale, c.Maintenance, c.MaintenanceScalingExponent);
        v.OperationCost = (newCapacity/v.Capacity)*v.OperationCost + ((v.Capacity - newCapacity)/v.Capacity)*v.OperationCost*c.AvailableMaintenanceFactor;
        v.Cost = c.Cost*actualAmount;
        v.Amount = actualAmount;
        v.StorageCapacity = v.Capacity/365*c.SafetyStock;
        v.StorageCost = GetLogisticActionCost(c.Storage, v.StorageCapacity, i);
        variants.Add(v);
      }
      variants.Sort();
      return variants.FirstOrDefault();
    }

    public static double GetMaxCapacity(Conversion c, string regionName) {
      var maxCapacity = GetValue(c.MaxCapacities, regionName, -1);
      if (maxCapacity < 0) maxCapacity = GetValue(c.MaxCapacities, "Default", -2);
      return maxCapacity;
    }

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

    private static double GetValue(ValueParameterCollection values, string name, double defaultValue) {
      IValueParameter parameter;
      if (values.TryGetValue(name, out parameter))
        return ((DoubleValue) parameter.Value).Value;
      return defaultValue;
    }

    public static double ScalingPenalty(double scale, double minScale, double maxScale) {
      if (scale > maxScale)
        return Util.Sqr(scale-maxScale);
      if (scale < minScale)
        return 4*(minScale - scale)*scale/Util.Sqr(minScale) * 2;
      return 0;
    }

    public static double CapacityPenalty(double capacity, double maxCapacity) {
      if (capacity > maxCapacity) {
        if (maxCapacity == 0) {
          return Math.Pow(capacity, 2);
        } else {
          return Math.Pow((capacity - maxCapacity)/maxCapacity, 2);
        }
      }
      return 0;
    }

    public static double ScaledCost(double scale, double maxScale, double baseCost, double exponent) {
      if (scale > 10) return baseCost*Math.Pow(10, exponent - 1);
      return baseCost*Math.Pow(scale, exponent);
    }

  }
}