source: addons/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/Data/Conversion.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 System.Collections.Generic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using YamlDotNet.RepresentationModel;
using HEAL.Attic;

namespace HeuristicLab.BioBoost.Data {
  [StorableType("AFFEC6E6-4373-41FD-B43E-139449409C98")]
  [Item("Conversion", "Describes a conversion process including storage.")]
  public class Conversion : DataItem {

    #region Parameters
    public IValueParameter<StringValue> LabelParameter { get { return (IValueParameter<StringValue>)Parameters["Label"]; } }
    public IValueParameter<StringValue> FeedstockParameter { get { return (IValueParameter<StringValue>)Parameters["Feedstock"]; } }
    public IValueParameter<DoubleValue> CostParameter { get { return (IValueParameter<DoubleValue>)Parameters["Cost"]; } }
    public IValueParameter<DoubleValue> DesignCapacityParameter { get { return (IValueParameter<DoubleValue>)Parameters["DesignCapacity"]; } }
    public IValueParameter<DoubleValue> ConstructionParameter { get { return (IValueParameter<DoubleValue>)Parameters["Construction"]; } }
    public IValueParameter<DoubleValue> MinConstructionParameter { get { return (IValueParameter<DoubleValue>)Parameters["MinConstruction"]; } }
    public IValueParameter<DoubleValue> MaintenanceParameter { get { return (IValueParameter<DoubleValue>)Parameters["Maintenance"]; } }
    public IValueParameter<DoubleValue> MinMaintenanceParameter { get { return (IValueParameter<DoubleValue>)Parameters["MinMaintenance"]; } }
    public IValueParameter<DoubleValue> ConstructionScalingExponentParameter { get { return (IValueParameter<DoubleValue>)Parameters["ConstructionScalingExponent"]; } }
    public IValueParameter<DoubleValue> MaintenanceScalingExponentParameter { get { return (IValueParameter<DoubleValue>)Parameters["MaintenanceScalingExponent"]; } }
    public IValueParameter<DoubleValue> SafetyStockParameter { get { return (IValueParameter<DoubleValue>)Parameters["SafetyStock"]; } }
    public IValueParameter<DoubleValue> DryMatterLossParameter { get { return (IValueParameter<DoubleValue>)Parameters["DryMatterLoss"]; } }
    public IValueParameter<LogisticAction> StorageParameter { get { return (IValueParameter<LogisticAction>)Parameters["Storage"]; } }
    public IValueParameter<DoubleValue> UtilizationFactorParameter { get { return (IValueParameter<DoubleValue>)Parameters["UtilizationFactor"]; } }
    public IValueParameter<ValueParameterCollection> ProductsParameter { get { return (IValueParameter<ValueParameterCollection>)Parameters["Products"]; } }
    public IValueParameter<ValueParameterCollection> ConstructionEmissionsParameter { get { return (IValueParameter<ValueParameterCollection>)Parameters["ConstructionEmissions"]; } }
    public IValueParameter<ValueParameterCollection> AvailableCapacitiesParameter { get { return (IValueParameter<ValueParameterCollection>)Parameters["AvailableCapacities"]; } }
    public IValueParameter<ValueParameterCollection> MaxCapacitiesParameter { get { return (IValueParameter<ValueParameterCollection>)Parameters["MaxCapacities"]; } }
    public IValueParameter<DoubleValue> AvailableMaintenanceFactorParameter { get { return (IValueParameter<DoubleValue>)Parameters["AvailableMaintenanceFactor"]; } }
    public IValueParameter<DoubleValue> MinCapacityParameter { get { return (IValueParameter<DoubleValue>) Parameters["MinCapacity"]; } }
    public IValueParameter<StringValue> MainProductParameter { get { return (IValueParameter<StringValue>)Parameters["MainProduct"]; } }
    public IValueParameter<DoubleValue> MainProductConversionRateParameter { get { return (IValueParameter<DoubleValue>)Parameters["MainProductConversionRate"]; } }
    #endregion

    #region Parameter Values
    public string Label { get { return LabelParameter.Value.Value; } }
    public string Feedstock { get { return FeedstockParameter.Value.Value; } }
    public string MainProduct { get { return MainProductParameter.Value.Value; } set { MainProductParameter.Value.Value = value; }
    }

    public double Cost { get { return CostParameter.Value.Value; } set { CostParameter.Value.Value = value; } }

    public double DesignCapacity { get { return DesignCapacityParameter.Value.Value; } }
    public double Construction { get { return ConstructionParameter.Value.Value; } }
    public double MinConstruction { get { return MinConstructionParameter.Value.Value; } }
    public double Maintenance { get { return MaintenanceParameter.Value.Value; } }
    public double MinMaintenance { get { return MinMaintenanceParameter.Value.Value; } }
    public double ConstructionScalingExponent { get { return ConstructionScalingExponentParameter.Value.Value; } }
    public double MaintenanceScalingExponent { get { return MaintenanceScalingExponentParameter.Value.Value; } }
    public double SafetyStock { get { return SafetyStockParameter.Value.Value; } }
    public double DryMatterLoss { get { return DryMatterLossParameter.Value.Value; } }
    public double UtilizationFactor { get { return UtilizationFactorParameter.Value.Value; } }
    public LogisticAction Storage { get { return StorageParameter.Value; } }
    public ValueParameterCollection Products { get { return ProductsParameter.Value; } }
    public ValueParameterCollection ConstructionEmissions { get { return ConstructionEmissionsParameter.Value; } }
    public ValueParameterCollection MaxCapacities { get { return MaxCapacitiesParameter.Value; } }
    public ValueParameterCollection AvailableCapacities { get { return AvailableCapacitiesParameter.Value; } }
    public double AvailableMaintenanceFactor { get { return AvailableMaintenanceFactorParameter.Value.Value; } }
    public double MainProductConversionRate {
      get { return MainProductConversionRateParameter.Value.Value; }
      set { MainProductConversionRateParameter.Value = new DoubleValue(value); }
    }

    public double MinCapacity {
      get {
        double minCapacity = MinCapacityParameter.Value.Value;
        if (minCapacity == 0d)
          minCapacity = MinCapacityParameter.Value.Value = GetInferredMinCapacity();
        return minCapacity;
      }
    }

    private double GetInferredMinCapacity() {
      if (MinConstructionParameter.Value != null && // reconstruct from MinConstruction
          ConstructionParameter.Value != null &&
          DesignCapacityParameter.Value != null &&
          ConstructionScalingExponentParameter.Value != null)
        return Math.Pow(MinConstruction / Construction, 1 / ConstructionScalingExponent) * DesignCapacity;
      if (MinMaintenanceParameter.Value != null && // reconstruct from MinMaintenance
          MaintenanceParameter.Value != null &&
          MaintenanceScalingExponentParameter.Value != null &&
          DesignCapacityParameter.Value != null)
        return Math.Pow(MinMaintenance / Maintenance, 1 / MaintenanceScalingExponent) * DesignCapacity;
      throw new IndexOutOfRangeException("MinCapacity is not available and could be reconstructed from other parameters.");
    }

    #endregion

    #region Construction & Cloning
    public Conversion() {
      Parameters.Add(new ValueParameter<StringValue>("Label", "The label/name of this conversion."));
      Parameters.Add(new ValueParameter<StringValue>("Feedstock", "The product used as feedstock (@target)."));
      Parameters.Add(new ValueParameter<DoubleValue>("Cost", "The conversion cost [EUR/t]."));
      Parameters.Add(new ValueParameter<DoubleValue>("Construction", "The amortized construction costs [EUR/a]"));
      Parameters.Add(new ValueParameter<DoubleValue>("Maintenance", "The amortized operation and maintenance costs [EUR/a]"));
      Parameters.Add(new ValueParameter<DoubleValue>("DesignCapacity", "The yearly turnover of feedstock [t/a]."));
      Parameters.Add(new ValueParameter<DoubleValue>("MinConstruction", "The minimum construction costs [EUR/a]"));
      Parameters.Add(new ValueParameter<DoubleValue>("MinMaintenance", "The minimum maintenance costs [EUR/a]"));
      Parameters.Add(new ValueParameter<DoubleValue>("ConstructionScalingExponent", "The exponent used for up- and downsising construction costs.", new DoubleValue(0.86)));
      Parameters.Add(new ValueParameter<DoubleValue>("MaintenanceScalingExponent", "The exponent used for up- and downscaling maintenance costs.", new DoubleValue(0.91)));
      Parameters.Add(new ValueParameter<DoubleValue>("SafetyStock", "The number of days feedstock needs to be stored on average."));
      Parameters.Add(new ValueParameter<DoubleValue>("DryMatterLoss", "The percentage of feedstock that is lost due to shrinkage.", new DoubleValue(0.0)));
      Parameters.Add(new ValueParameter<DoubleValue>("UtilizationFactor", "Assumed utilization of a plant.", new DoubleValue(0.7)));
      Parameters.Add(new ValueParameter<LogisticAction>("Storage", "Description of storage cost components [EUR/t/a]"));
      Parameters.Add(new ValueParameter<ValueParameterCollection>("Products", "The list and amounts of products created by the conversion."));
      Parameters.Add(new ValueParameter<ValueParameterCollection>("ConstructionEmissions", "The set of amortized emissions and amounts [t/a]"));
      Parameters.Add(new ValueParameter<ValueParameterCollection>("AvailableCapacities", "Dictionary of regions with their free capacities of this conversion type."));
      Parameters.Add(new ValueParameter<ValueParameterCollection>("MaxCapacities", "Dictionary of regions (or 'Default') with their maximum allows capapcity for this conversion type."));
      Parameters.Add(new ValueParameter<DoubleValue>("AvailableMaintenanceFactor", "Scaling factor for maintenance costs when using free capacities."));
      Parameters.Add(new ValueParameter<DoubleValue>("MinCapacity", "Minimum capacity to be reasonably build."));
      Parameters.Add(new ValueParameter<StringValue>("MainProduct", "The main output product created during this conversion process."));
      Parameters.Add(new ValueParameter<DoubleValue>("MainProductConversionRate", "The conversion rate of the main output product. (This value is automatically calculated)"));
      RegisterEventHandlers();
    }

    [StorableConstructor]
    protected Conversion(StorableConstructorFlag _) : base(_) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("AvailableCapacities"))
        Parameters.Add(new ValueParameter<ValueParameterCollection>("AvailableCapacities", "Dictionary of regions with their free capacities of this conversion type."));
      if (!Parameters.ContainsKey("MaxCapacities"))
        Parameters.Add(new ValueParameter<ValueParameterCollection>("MaxCapacities", "Dictionary of regions (or 'Default') with their maximum allows capapcity for this conversion type."));
      if (!Parameters.ContainsKey("AvailableMaintenanceFactor"))
        Parameters.Add(new ValueParameter<DoubleValue>("AvailableMaintenanceFactor", "Scaling factor for maintenance costs when using free capacities."));
      if (!Parameters.ContainsKey("DryMatterLoss"))
        Parameters.Add(new ValueParameter<DoubleValue>("DryMatterLoss", "The percentage of feedstock that is lost due to shrinkage.", new DoubleValue(0.0)));
      if (!Parameters.ContainsKey("MinCapacity"))
        Parameters.Add(new ValueParameter<DoubleValue>("MinCapacity", "Minimum capacity to be reasonably build.", new DoubleValue(GetInferredMinCapacity())));
      if (!Parameters.ContainsKey("MainProduct"))
        Parameters.Add(new ValueParameter<StringValue>("MainProduct", "The main output product created during this conversion process."));
      if (!Parameters.ContainsKey("MainProductConversionRate"))
      Parameters.Add(new ValueParameter<DoubleValue>("MainProductConversionRate", "The conversion rate of the main output product. (This value is automatically calculated)"));
      RegisterEventHandlers();
    }

    protected Conversion(Conversion orig, Cloner cloner)
      : base(orig, cloner) {
      RegisterEventHandlers();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new Conversion(this, cloner);
    }
    #endregion

    protected override void Parse(YamlMappingNode node) {
      base.Parse(node);
      MaybeDetermineMainProductConversionRate();
    }

    private void MaybeDetermineMainProductConversionRate() {
      if (MainProductParameter.Value != null &&
          (MainProductConversionRateParameter.Value == null || MainProductConversionRate == 0))
        MainProductConversionRate = ((DoubleValue) Products[MainProduct].Value).Value;
    }

    public override void CollectParameterValues(System.Collections.Generic.IDictionary<string, IItem> values) {
      var tmpDict = new Dictionary<string, IItem>();
      base.CollectParameterValues(tmpDict);
      foreach (var entry in tmpDict) {
        if (entry.Key == "Label") continue;
        if (entry.Key == "Feedstock") continue;
        values.Add("Conversion " + Label + "." + Feedstock + "." + entry.Key, entry.Value);
      }
    }

    private void RegisterEventHandlers() {
      // when the HL value is changed
      LabelParameter.ValueChanged += (sender, args) => {
        UpdateName();
        LabelParameter.Value.ValueChanged += (s, a) => { UpdateName(); };
      };
      // when the HL value's value is changed
      LabelParameter.Value.ValueChanged += (sender, args) => { UpdateName(); };
    }

    private void UpdateName() {
      this.Name = ItemName + ": " + Label;
    }

    public override bool IsEquivalentTo(DataItem other) {
      var c = other as Conversion;
      if (c == null) return false;
      return c.Label == Label;
    }

    public void MaybeInferMainProduct(Dictionary<string, double> prices) {
      if (MainProductParameter.Value != null) { return; }
      string mainProductName = null;
      double mainProductRevenue = 0;
      foreach (var product in Products) {
        double price = 0;
        if (prices.TryGetValue(product.Name, out price) && product.Value is ValueParameter<DoubleValue>) {
          var doubleValue = (IValueParameter<DoubleValue>)product;
          var revenue = price*doubleValue.Value.Value;
          if (mainProductName == null && revenue > 0 || revenue > mainProductRevenue) {
            mainProductName = product.Name;
            mainProductRevenue = revenue;
          }
        }
      }
      if (mainProductName != null) {
        MainProduct = MainProduct;
        MaybeDetermineMainProductConversionRate();
      }
    }
  }
}