refactoring: implementing BusAuxModules in new C# project

VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{550D99D4-25F7-48D9-B0F0-E5DD6CB3485D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>TUGraz.VectoCore.BusAuxiliaries</RootNamespace>
+    <AssemblyName>BusAuxiliariesC</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="DownstreamModules\Impl\AbstractModule.cs" />
+    <Compile Include="DownstreamModules\Impl\M00Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M02Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M03Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M04Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M05Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M0_5Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M10Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M11Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M12Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M13Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M14Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M01Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M06Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M07Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M08Impl.cs" />
+    <Compile Include="DownstreamModules\Impl\M09Impl.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\VectoCommon\AdvancedAuxiliaryInterfaces\AdvancedAuxiliaryInterfaces.vbproj">
+      <Project>{B4B9BD2F-FD8F-4BB8-82FA-E2154D2C7FBD}</Project>
+      <Name>AdvancedAuxiliaryInterfaces</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\VectoCommon\VectoCommon\VectoCommon.csproj">
+      <Project>{79A066AD-69A9-4223-90F6-6ED5D2D084F4}</Project>
+      <Name>VectoCommon</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/AbstractModule.cs

+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public abstract class AbstractModule
+	{
+		protected bool calculationValid { get; private set; }
+
+		public AbstractModule()
+		{
+			calculationValid = false;
+		}
+
+		public virtual void ResetCalculations()
+		{
+			calculationValid = false;
+		}
+
+		protected virtual void Calculate()
+		{
+			DoCalculate();
+			calculationValid = true;
+		}
+
+		protected virtual void DoCalculate() { }
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M00Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules.Electrics;
+using VectoAuxiliaries.Electrics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M00Impl : AbstractModule, IM0_NonSmart_AlternatorsSetEfficiency
+	{
+		protected Ampere _getHVACElectricalPowerDemandAmps;
+		protected double _alternatorsEfficiency;
+		protected IElectricalConsumerList _electricalConsumersList;
+		protected IAlternatorMap _alternatorEfficiencyMap;
+		protected Volt _powernetVoltage;
+		protected ISignals _signals;
+		protected ISSMTOOL _steadyStateModelHVAC;
+		protected Watt _ElectricalPowerW;
+		protected Watt _MechanicalPowerW;
+		protected LiterPerSecond _FuelingLPerH;
+
+		public M00Impl(
+			IElectricalConsumerList electricalConsumers, IAlternatorMap alternatorEfficiencyMap, Volt powernetVoltage,
+			ISignals signals, ISSMTOOL ssmHvac)
+		{
+			if (electricalConsumers == null) {
+				throw new ArgumentException("No ElectricalConsumersList Supplied");
+			}
+
+			if (alternatorEfficiencyMap == null) {
+				throw new ArgumentException("No Alternator Efficiency Map Supplied");
+			}
+
+			if (powernetVoltage < ElectricConstants.PowenetVoltageMin || powernetVoltage > ElectricConstants.PowenetVoltageMax) {
+				throw new ArgumentException("Powernet Voltage out of range");
+			}
+
+			if (signals == null) {
+				throw new ArgumentException("No Signals reference was supplied.");
+			}
+
+			_electricalConsumersList = electricalConsumers;
+
+			_alternatorEfficiencyMap = alternatorEfficiencyMap;
+
+			_powernetVoltage = powernetVoltage;
+
+			_signals = signals;
+
+			_steadyStateModelHVAC = ssmHvac;
+
+			_ElectricalPowerW = ssmHvac.ElectricalWAdjusted.SI<Watt>();
+
+			_MechanicalPowerW = ssmHvac.MechanicalWBaseAdjusted.SI<Watt>();
+
+			_FuelingLPerH = ssmHvac.FuelPerHBaseAdjusted.SI<LiterPerSecond>();
+		}
+
+		#region Implementation of IM0_NonSmart_AlternatorsSetEfficiency
+
+		public Ampere GetHVACElectricalPowerDemandAmps
+		{
+			get { return _ElectricalPowerW / _powernetVoltage; }
+		}
+
+		public double AlternatorsEfficiency
+		{
+			get {
+				var baseCurrentDemandAmps = _electricalConsumersList.GetTotalAverageDemandAmps(false);
+				var totalDemandAmps = baseCurrentDemandAmps + GetHVACElectricalPowerDemandAmps;
+				return _alternatorEfficiencyMap.GetEfficiency(_signals.EngineSpeed.AsRPM, totalDemandAmps).Efficiency;
+			}
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M01Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules.Electrics;
+using VectoAuxiliaries.Electrics;
+using VectoAuxiliaries.Hvac;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M01Impl : AbstractModule, IM1_AverageHVACLoadDemand
+	{
+		protected IM0_NonSmart_AlternatorsSetEfficiency _m0;
+		protected Double _alternatorGearEfficiency;
+		protected Double _compressorGearEfficiency;
+		protected ISignals _signals;
+		protected Volt _powernetVoltage;
+		protected ISSMTOOL _steadyStateModel;
+
+		protected Watt _ElectricalPowerW;
+		protected Watt _MechanicalPowerW;
+		protected LiterPerSecond _FuelingLPerH;
+
+		public M01Impl(IM0_NonSmart_AlternatorsSetEfficiency m0, double altGearEfficiency, double compressorGearEfficiency, Volt powernetVoltage, ISignals signals, ISSMTOOL ssm)
+		{
+			//'Sanity Check - Illegal operations without all params.
+			if (m0 == null) {
+				throw new ArgumentException("Module0 as supplied is null");
+			}
+
+			if (altGearEfficiency < ElectricConstants.AlternatorPulleyEfficiencyMin ||
+				altGearEfficiency > ElectricConstants.AlternatorPulleyEfficiencyMax) {
+				throw new ArgumentException(
+					string.Format
+					(
+						"Gear efficiency must be between {0} and {1}",
+						ElectricConstants.AlternatorPulleyEfficiencyMin, ElectricConstants.AlternatorPulleyEfficiencyMax));
+			}
+			if (signals == null) {
+				throw new Exception("Signals object as supplied is null");
+			}
+
+			if (powernetVoltage < ElectricConstants.PowenetVoltageMin || powernetVoltage > ElectricConstants.PowenetVoltageMax) {
+				throw new ArgumentException(
+					string.Format(
+						"PowenetVoltage supplied must be in the range {0} to {1}", ElectricConstants.PowenetVoltageMin,
+						ElectricConstants.PowenetVoltageMax));
+			}
+
+			if (ssm == null ) {
+				throw new ArgumentException("Steady State model was not supplied");
+			}
+
+			if (compressorGearEfficiency < 0 || altGearEfficiency > 1) {
+				throw new ArgumentException(String.Format("Compressor Gear efficiency must be between {0} and {1}", 0, 1));
+			}
+
+			//'Assign
+			_m0 = m0;
+			_alternatorGearEfficiency = altGearEfficiency;
+			_signals = signals;
+
+			_compressorGearEfficiency = compressorGearEfficiency;
+			_powernetVoltage = powernetVoltage;
+
+
+			_steadyStateModel = ssm;
+
+			_ElectricalPowerW = ssm.ElectricalWAdjusted.SI<Watt>();
+			_MechanicalPowerW = ssm.MechanicalWBaseAdjusted.SI<Watt>();
+			_FuelingLPerH = ssm.FuelPerHBaseAdjusted.SI(Unit.SI.Liter.Per.Hour).Cast<LiterPerSecond>(); // ' SI(Of LiterPerHour)()
+
+		}
+
+		#region Implementation of IM1_AverageHVACLoadDemand
+
+		public Watt AveragePowerDemandAtCrankFromHVACMechanicalsWatts()
+		{
+			return _MechanicalPowerW * (1 / _compressorGearEfficiency);
+		}
+
+		public Watt AveragePowerDemandAtAlternatorFromHVACElectricsWatts()
+		{
+			return _ElectricalPowerW;
+		}
+
+		public Watt AveragePowerDemandAtCrankFromHVACElectricsWatts()
+		{
+			return _ElectricalPowerW * (1 / _m0.AlternatorsEfficiency / _alternatorGearEfficiency);
+		}
+
+		public LiterPerSecond HVACFuelingLitresPerHour()
+		{
+			return _FuelingLPerH;
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M02Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules.Electrics;
+using VectoAuxiliaries.Electrics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M02Impl : AbstractModule, IM2_AverageElectricalLoadDemand
+	{
+		private Volt _powerNetVoltage;
+		private IElectricalConsumerList _electricalConsumers;
+		private IM0_NonSmart_AlternatorsSetEfficiency _module0;
+		private double _alternatorPulleyEffiency;
+
+		public M02Impl(
+			IElectricalConsumerList electricalConsumers, IM0_NonSmart_AlternatorsSetEfficiency m0, double altPulleyEfficiency,
+			Volt powerNetVoltage, ISignals signals)
+		{
+			if (electricalConsumers == null) {
+				throw new ArgumentException("Electrical Consumer List must be supplied");
+			}
+			if (m0 == null) {
+				throw new ArgumentException("Must supply module 0");
+			}
+			if (altPulleyEfficiency.IsEqual(0) || altPulleyEfficiency > 1) {
+				throw new ArgumentException("Alternator Gear efficiency out of range.");
+			}
+			if (powerNetVoltage < ElectricConstants.PowenetVoltageMin || powerNetVoltage > ElectricConstants.PowenetVoltageMax) {
+				throw new ArgumentException("Powernet Voltage out of known range.");
+			}
+
+			_powerNetVoltage = powerNetVoltage;
+			_electricalConsumers = electricalConsumers;
+			_module0 = m0;
+			_alternatorPulleyEffiency = altPulleyEfficiency;
+		}
+
+		#region Implementation of IM2_AverageElectricalLoadDemand
+
+		public Watt GetAveragePowerDemandAtAlternator()
+		{
+			return _powerNetVoltage * _electricalConsumers.GetTotalAverageDemandAmps(false);
+		}
+
+		public Watt GetAveragePowerAtCrankFromElectrics()
+		{
+			var ElectricalPowerDemandsWatts = GetAveragePowerDemandAtAlternator();
+			var alternatorsEfficiency = _module0.AlternatorsEfficiency;
+			var ElectricalPowerDemandsWattsDividedByAlternatorEfficiency =
+				ElectricalPowerDemandsWatts * (1 / alternatorsEfficiency);
+
+			var averagePowerDemandAtCrankFromElectricsWatts =
+				ElectricalPowerDemandsWattsDividedByAlternatorEfficiency * (1 / _alternatorPulleyEffiency);
+
+			return averagePowerDemandAtCrankFromElectricsWatts;
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M03Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M03Impl : AbstractModule, IM3_AveragePneumaticLoadDemand
+	{
+		private IPneumaticUserInputsConfig _pneumaticUserInputsConfig;
+		private IPneumaticsAuxilliariesConfig _pneumaticAuxillariesConfig;
+		private IPneumaticActuationsMAP _pneumaticsActuationsMap;
+		private ICompressorMap _pneumaticsCompressorFlowRateMap;
+		private Kilogram _vehicleMassKG;
+		private string _cycleName;
+		private ISignals _signals;
+		private SI _averagePowerDemandPerCompressorUnitFlowRateInWPerLitresPerSecond;
+		private NormLiter _totalAirDemand;
+
+		private double _cycleDurationMinutes;
+
+		public M03Impl(IPneumaticUserInputsConfig pneumaticsUserInputConfig, IPneumaticsAuxilliariesConfig pneumaticsAuxillariesConfig, IPneumaticActuationsMAP pneumaticsActuationsMap, ICompressorMap pneumaticsCompressorFlowRateMap, Kilogram vehicleMassKG, string cycleName, ISignals signals)
+		{
+			_pneumaticUserInputsConfig = pneumaticsUserInputConfig;
+			_pneumaticAuxillariesConfig = pneumaticsAuxillariesConfig;
+			_pneumaticsActuationsMap = pneumaticsActuationsMap;
+			_pneumaticsCompressorFlowRateMap = pneumaticsCompressorFlowRateMap;
+			_vehicleMassKG = vehicleMassKG;
+			_cycleName = cycleName;
+			_signals = signals;
+
+
+			//'Total up the blow demands from compressor map
+			_averagePowerDemandPerCompressorUnitFlowRateInWPerLitresPerSecond =
+				(_pneumaticsCompressorFlowRateMap.GetAveragePowerDemandPerCompressorUnitFlowRate() / 60).SI();
+
+			//'Calculate the Total Required Air Delivery Rate L / S
+			_totalAirDemand = TotalAirDemandCalculation();
+		}
+
+
+		private NormLiter TotalAirDemandCalculation()
+		{
+			//'These calculation are done directly from formulae provided from a supplied spreadsheet.
+
+			//'* * Breaks * *
+			double numActuationsPerCycle = _pneumaticsActuationsMap.GetNumActuations(new ActuationsKey("Brakes", _cycleName));
+			//'=IF(K10 = "yes", IF(COUNTBLANK(F33), G33, F33), IF(COUNTBLANK(F34), G34, F34)) * K16
+			var airConsumptionPerActuationNI = _pneumaticUserInputsConfig.RetarderBrake
+				? _pneumaticAuxillariesConfig.BrakingWithRetarderNIperKG
+				: _pneumaticAuxillariesConfig.BrakingNoRetarderNIperKG;
+			var Breaks = (numActuationsPerCycle * airConsumptionPerActuationNI * _vehicleMassKG.Value()).SI<NormLiter>();
+
+			//'* * ParkBrakesBreakplus2Doors * *Park break +2 doors
+			numActuationsPerCycle =
+				_pneumaticsActuationsMap.GetNumActuations(new ActuationsKey("Park brake + 2 doors", _cycleName));
+			//'=SUM(IF(K14 = "electric", 0, IF(COUNTBLANK(F36), G36, F36)), PRODUCT(K16 * IF(COUNTBLANK(F37), G37, F37)))
+			airConsumptionPerActuationNI = _pneumaticUserInputsConfig.Doors == "Electric"
+				? 0
+				: _pneumaticAuxillariesConfig.PerDoorOpeningNI;
+			airConsumptionPerActuationNI += _pneumaticAuxillariesConfig.PerStopBrakeActuationNIperKG * _vehicleMassKG.Value();
+			var ParkBrakesplus2Doors = (numActuationsPerCycle * airConsumptionPerActuationNI).SI<NormLiter>();
+
+			//'* * Kneeling * *
+			numActuationsPerCycle = _pneumaticsActuationsMap.GetNumActuations(new ActuationsKey("Kneeling", _cycleName));
+			//'=IF(COUNTBLANK(F35), G35, F35) * K11 * K16
+			airConsumptionPerActuationNI = _pneumaticAuxillariesConfig.BreakingPerKneelingNIperKGinMM * _vehicleMassKG.Value() *
+											_pneumaticUserInputsConfig.KneelingHeightMillimeters;
+			var Kneeling = (numActuationsPerCycle * airConsumptionPerActuationNI).SI<NormLiter>();
+
+			//'* * AdBlue * *
+			//	'=IF(K13 = "electric", 0, G39 * F54) - Supplied Spreadsheet
+			var AdBlue = (_pneumaticUserInputsConfig.AdBlueDosing == "Electric" ? 0 :
+				_pneumaticAuxillariesConfig.AdBlueNIperMinute * (_signals.TotalCycleTimeSeconds / 60.0)).SI<NormLiter>();
+
+			//'* * Regeneration * *
+			//	'=SUM(R6: R9) * IF(K9 = "yes", IF(COUNTBLANK(F41), G41, F41), IF(COUNTBLANK(F40), G40, F40)) - Supplied SpreadSheet
+			var Regeneration = Breaks + ParkBrakesplus2Doors + Kneeling + AdBlue;
+			var regenFraction = _pneumaticUserInputsConfig.SmartRegeneration
+				? _pneumaticAuxillariesConfig.SmartRegenFractionTotalAirDemand
+				: _pneumaticAuxillariesConfig.NonSmartRegenFractionTotalAirDemand;
+			Regeneration = Regeneration * regenFraction;
+
+			//'* * DeadVolBlowOuts * *
+			//	'=IF(COUNTBLANK(F43), G43, F43) / (F54 / 60) - Supplied SpreadSheet
+			numActuationsPerCycle = _pneumaticAuxillariesConfig.DeadVolBlowOutsPerLitresperHour /
+									(60.0 / (_signals.TotalCycleTimeSeconds / 60.0));
+			airConsumptionPerActuationNI = _pneumaticAuxillariesConfig.DeadVolumeLitres;
+			var DeadVolBlowOuts = (numActuationsPerCycle * airConsumptionPerActuationNI).SI<NormLiter>();
+
+			//'* * AirSuspension * *
+			//	'=IF(K12 = "electrically", 0, G38 * F54) - Suplied Spreadsheet
+			var AirSuspension = (_pneumaticUserInputsConfig.AirSuspensionControl == "Electrically" ?  0 :
+				_pneumaticAuxillariesConfig.AirControlledSuspensionNIperMinute * _cycleDurationMinutes).SI<NormLiter>();
+
+			//'* * Total Air Demand**
+			var TotalAirDemand = Breaks + ParkBrakesplus2Doors + Kneeling + AdBlue + Regeneration + DeadVolBlowOuts +
+								AirSuspension;
+
+
+			return TotalAirDemand;
+		}
+
+		
+		#region Implementation of IM3_AveragePneumaticLoadDemand
+
+		public Watt GetAveragePowerDemandAtCrankFromPneumatics()
+		{
+			var Sum1 = _totalAirDemand / _signals.TotalCycleTimeSeconds.SI<Second>();
+			var Sum6 = _pneumaticsCompressorFlowRateMap.GetFlowRate(
+							_signals.EngineSpeed.AsRPM * _pneumaticUserInputsConfig.CompressorGearRatio) /
+						60;
+			var pon = _pneumaticsCompressorFlowRateMap.GetPowerCompressorOn(
+					_signals.EngineSpeed.AsRPM * _pneumaticUserInputsConfig.CompressorGearRatio);
+			var poff = _pneumaticsCompressorFlowRateMap.GetPowerCompressorOff(
+					_signals.EngineSpeed.AsRPM * _pneumaticUserInputsConfig.CompressorGearRatio);
+			var diff = pon - poff;
+			var Sum7 = diff;
+
+			var Sum2 = (Sum7.Value() / Sum6.Value() * Sum1.Value()).SI<Watt>(); // ' Watt / Nl/s * Nl/s = Watt
+			var Sum3 = Sum2 +
+						_pneumaticsCompressorFlowRateMap.GetPowerCompressorOff(
+							_signals.EngineSpeed.AsRPM * _pneumaticUserInputsConfig.CompressorGearRatio);
+			var Sum4 = Sum3 * (1 / _pneumaticUserInputsConfig.CompressorGearEfficiency);
+			return Sum4;
+		}
+
+		public NormLiterPerSecond AverageAirConsumedPerSecondLitre()
+		{
+			var Sum1 = _totalAirDemand / _signals.TotalCycleTimeSeconds.SI<Second>();
+			return Sum1;
+		}
+
+		public NormLiter TotalAirDemand
+		{
+			get { return _totalAirDemand; }
+		}
+		
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M04Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M04Impl : AbstractModule, IM4_AirCompressor
+	{
+		private const double MinRatio = 1;
+		private const double MaxRatio = 10;
+		private const double MinEff = 0;
+		private const double MaxEff = 1;
+
+		private double _pulleyGearRatio;
+		private double _pulleyGearEfficiency;
+		private ICompressorMap _map;
+		private ISignals _signals;
+
+		public M04Impl(ICompressorMap map, double pulleyGearRatio, double pulleyGearEfficiency, ISignals signals)
+		{
+			_map = map;
+			_pulleyGearRatio = pulleyGearRatio;
+			_pulleyGearEfficiency = pulleyGearEfficiency;
+			_signals = signals;
+		}
+
+		#region Implementation of IM4_AirCompressor
+
+		public double PulleyGearRatio
+		{
+			get { return _pulleyGearRatio; }
+			set {
+				if (value < MinRatio || value > MaxRatio) {
+					throw new ArgumentOutOfRangeException(
+						"pulleyGearRatio", value,
+						string.Format("Invalid value, should be in the range {0} to {1}", MinRatio, MaxRatio));
+				}
+
+				_pulleyGearRatio = value;
+			}
+		}
+
+		public double PulleyGearEfficiency
+		{
+			get { return _pulleyGearEfficiency; }
+			set {
+				if (value < MinEff || value > MaxEff) {
+					throw new ArgumentOutOfRangeException(
+						"pulleyGearEfficiency", value,
+						String.Format("Invalid value, should be in the range {0} to {1}", MinEff, MaxEff)
+					);
+				}
+
+				_pulleyGearEfficiency = value;
+			}
+		}
+
+		public bool Initialise()
+		{
+			return _map.Initialise();
+		}
+
+		public NormLiterPerSecond GetFlowRate()
+		{
+			var compressorRpm = _signals.EngineSpeed.AsRPM * PulleyGearRatio;
+			return _map.GetFlowRate(compressorRpm) / 60;
+		}
+
+		public Watt GetPowerCompressorOff()
+		{
+			return GetCompressorPower(false);
+		}
+
+		public Watt GetPowerCompressorOn()
+		{
+			return GetCompressorPower(true);
+		}
+
+		public Watt GetPowerDifference()
+		{
+			var powerOn = GetPowerCompressorOn();
+			var powerOff = GetPowerCompressorOff();
+			return powerOn - powerOff;
+		}
+
+		public SI GetAveragePowerDemandPerCompressorUnitFlowRate()
+		{
+			return _map.GetAveragePowerDemandPerCompressorUnitFlowRate().SI();
+		}
+
+		#endregion
+
+		private Watt GetCompressorPower(bool compressorOn)
+		{
+			var compressorRpm = _signals.EngineSpeed.AsRPM * PulleyGearRatio;
+			return compressorOn ? _map.GetPowerCompressorOn(compressorRpm) : _map.GetPowerCompressorOff(compressorRpm);
+		}
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M05Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries.DownstreamModules.Electrics;
+using VectoAuxiliaries.Electrics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M05Impl : AbstractModule, IM5_SmartAlternatorSetGeneration
+	{
+		private IM0_5_SmartAlternatorSetEfficiency _m05;
+		private Volt _powerNetVoltage;
+		private double _alternatorGearEfficiency;
+
+		public M05Impl(IM0_5_SmartAlternatorSetEfficiency m05, Volt powernetVoltage, double alternatorGearEfficiency)
+		{
+			//'sanity check
+			if (m05 == null) {
+				throw new ArgumentException("Please supply a valid module M05");
+			}
+
+			if (powernetVoltage < ElectricConstants.PowenetVoltageMin || powernetVoltage > ElectricConstants.PowenetVoltageMax) {
+				throw new ArgumentException("Powernet Voltage out of range");
+			}
+			if (alternatorGearEfficiency < 0 || alternatorGearEfficiency > 1) {
+				throw new ArgumentException("AlternatorGearEfficiency Out of bounds, should be 0 to 1");
+			}
+
+			_m05 = m05;
+			_powerNetVoltage = powernetVoltage;
+			_alternatorGearEfficiency = alternatorGearEfficiency;
+		}
+
+		#region Implementation of IM5_SmartAlternatorSetGeneration
+
+		public Watt AlternatorsGenerationPowerAtCrankIdleWatts()
+		{
+			return _m05.SmartIdleCurrent * _powerNetVoltage *
+					(1 / (_m05.AlternatorsEfficiencyIdleResultCard * _alternatorGearEfficiency));
+		}
+
+		public Watt AlternatorsGenerationPowerAtCrankTractionOnWatts()
+		{
+			return _m05.SmartTractionCurrent * _powerNetVoltage *
+					(1 / (_m05.AlternatorsEfficiencyTractionOnResultCard * _alternatorGearEfficiency));
+		}
+
+		public Watt AlternatorsGenerationPowerAtCrankOverrunWatts()
+		{
+			return _m05.SmartOverrunCurrent * _powerNetVoltage *
+					(1 / (_m05.AlternatorsEfficiencyOverrunResultCard * _alternatorGearEfficiency));
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M06Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Electrics;
+using VectoAuxiliaries.Hvac;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M06Impl : AbstractModule, IM6
+	{
+		protected bool _overrunFlag;
+		protected bool _smartElecAndPneumaticsCompressorFlag;
+		protected Watt _smartElecAndPneumaticAltPowerGenAtCrank;
+		protected Watt _smartElecAndPneumaticAirCompPowerGenAtCrank;
+		protected Watt _smartElecOnlyAltPowerGenAtCrank;
+		protected Watt _averagePowerDemandAtCrankFromPneumatics;
+		protected Watt _smartPneumaticOnlyAirCompPowerGenAtCrank;
+		protected Watt _avgPowerDemandAtCrankFromElectricsIncHVAC;
+		protected bool _smartPneumaticsOnlyCompressorFlag;
+
+		protected IM1_AverageHVACLoadDemand _m1;
+		protected IM2_AverageElectricalLoadDemand _m2;
+		protected IM3_AveragePneumaticLoadDemand _m3;
+		protected IM4_AirCompressor _m4;
+		protected IM5_SmartAlternatorSetGeneration _m5;
+		protected ISignals _signals;
+
+		public M06Impl(
+			IM1_AverageHVACLoadDemand m1, IM2_AverageElectricalLoadDemand m2, IM3_AveragePneumaticLoadDemand m3,
+			IM4_AirCompressor m4, IM5_SmartAlternatorSetGeneration m5, ISignals signals)
+		{
+			_m1 = m1;
+			_m2 = m2;
+			_m3 = m3;
+			_m4 = m4;
+			_m5 = m5;
+			_signals = signals;
+		}
+
+		protected override void DoCalculate()
+		{
+			var sum1 = _m1.AveragePowerDemandAtCrankFromHVACElectricsWatts() + _m2.GetAveragePowerAtCrankFromElectrics();
+			var sw1 = _signals.SmartElectrics ? _m5.AlternatorsGenerationPowerAtCrankTractionOnWatts() : sum1;
+			var sum2 = _m1.AveragePowerDemandAtCrankFromHVACMechanicalsWatts() + sw1 +
+						_m3.GetAveragePowerDemandAtCrankFromPneumatics();
+			var sum3 = _signals.EngineMotoringPower + _signals.InternalEnginePower + sum2;
+			var vc0 = sum3 <= 0;
+
+			var sum4 = sum3 - sw1 - _m3.GetAveragePowerDemandAtCrankFromPneumatics() + _m4.GetPowerCompressorOff();
+			var sum5 = vc0 ? sum4 : 0.SI<Watt>();
+			var sum10 = _m5.AlternatorsGenerationPowerAtCrankOverrunWatts() * -1.0;
+			var max1 = sum5 > sum10 ? sum5 : sum10;
+			var sum11 = sum5 - max1;
+			var sum12 = _m4.GetPowerDifference() + sum11;
+			var vc2 = sum12 < 0 || sum12.IsEqual(0);
+
+			var vc1 = sum12 > 0;
+			var sum14 = vc1 ? _m4.GetPowerCompressorOff() : 0.SI<Watt>();
+			var sum15 = vc2 ? _m4.GetPowerCompressorOn() * _signals.PneumaticOverrunUtilisation : 0.SI<Watt>();
+			var sum16 = sum14 + sum15;
+
+			var sum6 = sum4 - _m4.GetPowerCompressorOff() + _m3.GetAveragePowerDemandAtCrankFromPneumatics();
+			var sum7 = vc0 ? sum6 : 0.SI<Watt>();
+			var max2 = sum7 > sum10 ? sum7 : sum10;
+
+			var sum8 = sum4 + sw1;
+			var sum9 = vc0 ? sum8 : 0.SI<Watt>();
+			var sum13 = sum9 + _m4.GetPowerDifference();
+			var vc3 = sum13 > 0;
+			var vc4 = sum13 < 0 || sum13.IsEqual(0);
+			var sum17 = vc3 ? _m4.GetPowerCompressorOff() : 0.SI<Watt>();
+			var sum18 = vc4 ? _m4.GetPowerCompressorOn() * _signals.PneumaticOverrunUtilisation : 0.SI<Watt>();
+			var sum19 = sum17 + sum18;
+
+			_overrunFlag = vc0;
+			_smartElecAndPneumaticsCompressorFlag = vc2;
+			_smartElecAndPneumaticAltPowerGenAtCrank = max1 * -1;
+			_smartElecAndPneumaticAirCompPowerGenAtCrank = sum16;
+			_smartElecOnlyAltPowerGenAtCrank = max2 * -1;
+			_averagePowerDemandAtCrankFromPneumatics = _m3.GetAveragePowerDemandAtCrankFromPneumatics();
+			_smartPneumaticOnlyAirCompPowerGenAtCrank = sum19;
+			_avgPowerDemandAtCrankFromElectricsIncHVAC = sum1;
+			_smartPneumaticsOnlyCompressorFlag = vc4;
+		}
+
+		#region Implementation of IM6
+
+		public bool OverrunFlag
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _overrunFlag;
+			}
+		}
+
+		public bool SmartElecAndPneumaticsCompressorFlag
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElecAndPneumaticsCompressorFlag; }
+		}
+
+		public Watt SmartElecAndPneumaticAltPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElecAndPneumaticAltPowerGenAtCrank; }
+		}
+
+		public Watt SmartElecAndPneumaticAirCompPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElecAndPneumaticAirCompPowerGenAtCrank; }
+		}
+
+		public Watt SmartElecOnlyAltPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElecOnlyAltPowerGenAtCrank; }
+		}
+
+		public Watt AveragePowerDemandAtCrankFromPneumatics
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _averagePowerDemandAtCrankFromPneumatics; }
+		}
+
+		public Watt SmartPneumaticOnlyAirCompPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartPneumaticOnlyAirCompPowerGenAtCrank; }
+		}
+
+		public Watt AvgPowerDemandAtCrankFromElectricsIncHVAC
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _avgPowerDemandAtCrankFromElectricsIncHVAC; }
+		}
+
+		public bool SmartPneumaticsOnlyCompressorFlag
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartPneumaticsOnlyCompressorFlag; }
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M07Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Electrics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M07Impl : AbstractModule, IM7
+	{
+		protected Watt _smartElectricalAndPneumaticAuxAltPowerGenAtCrank;
+		protected Watt _smartElectricalAndPneumaticAuxAirCompPowerGenAtCrank;
+		protected Watt _smartElectricalOnlyAuxAltPowerGenAtCrank;
+		protected Watt _smartPneumaticOnlyAuxAirCompPowerGenAtCrank;
+
+		protected IM5_SmartAlternatorSetGeneration _m5;
+		protected IM6 _m6;
+		protected ISignals _signals;
+
+		public M07Impl(IM5_SmartAlternatorSetGeneration m5, IM6 m6, ISignals signals)
+		{
+			_m5 = m5;
+			_m6 = m6;
+			_signals = signals;
+		}
+
+		protected override void DoCalculate()
+		{
+			var idle = _signals.EngineSpeed <= _signals.EngineIdleSpeed &&
+						(!_signals.ClutchEngaged || _signals.InNeutral);
+
+			var sw1 = idle
+				? _m5.AlternatorsGenerationPowerAtCrankIdleWatts()
+				: _m5.AlternatorsGenerationPowerAtCrankTractionOnWatts();
+
+			var c1 = _m6.OverrunFlag && _signals.ClutchEngaged && _signals.InNeutral == false;
+			var sw2 = c1 ? _m6.SmartElecAndPneumaticAltPowerGenAtCrank : sw1;
+
+			var sw3 = c1 ? _m6.SmartElecAndPneumaticAirCompPowerGenAtCrank : _m6.AveragePowerDemandAtCrankFromPneumatics;
+
+			var sw4 = c1 ? _m6.SmartElecOnlyAltPowerGenAtCrank : sw1;
+
+			var sw5 = c1 ? _m6.SmartPneumaticOnlyAirCompPowerGenAtCrank : _m6.AveragePowerDemandAtCrankFromPneumatics;
+
+			_smartElectricalAndPneumaticAuxAltPowerGenAtCrank = sw2;
+			_smartElectricalAndPneumaticAuxAirCompPowerGenAtCrank = sw3;
+			_smartElectricalOnlyAuxAltPowerGenAtCrank = sw4;
+			_smartPneumaticOnlyAuxAirCompPowerGenAtCrank = sw5;
+		}
+
+		#region Implementation of IM7
+
+		public Watt SmartElectricalAndPneumaticAuxAltPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElectricalAndPneumaticAuxAltPowerGenAtCrank;
+			}
+		}
+
+		public Watt SmartElectricalAndPneumaticAuxAirCompPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElectricalAndPneumaticAuxAirCompPowerGenAtCrank;
+			}
+		}
+
+		public Watt SmartElectricalOnlyAuxAltPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElectricalOnlyAuxAltPowerGenAtCrank;
+			}
+		}
+
+		public Watt SmartPneumaticOnlyAuxAirCompPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartPneumaticOnlyAuxAirCompPowerGenAtCrank;
+			}
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M08Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Hvac;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M08Impl : AbstractModule, IM8
+	{
+		protected Watt _auxPowerAtCrankFromElectricalHVACAndPneumaticsAncillaries;
+		protected Watt _smartElectricalAlternatorPowerGenAtCrank;
+		protected bool _compressorFlag;
+
+		protected IM1_AverageHVACLoadDemand _m1;
+		protected IM6 _m6;
+		protected IM7 _m7;
+		protected ISignals _signals;
+
+		public M08Impl(IM1_AverageHVACLoadDemand m1, IM6 m6, IM7 m7, ISignals signals)
+		{
+			_m1 = m1;
+			_m6 = m6;
+			_m7 = m7;
+			_signals = signals;
+		}
+
+
+		protected override void DoCalculate()
+		{
+			var sum1 = _m7.SmartElectricalAndPneumaticAuxAltPowerGenAtCrank +
+						_m7.SmartElectricalAndPneumaticAuxAirCompPowerGenAtCrank;
+			var sum2 = _m7.SmartElectricalOnlyAuxAltPowerGenAtCrank + _m6.AveragePowerDemandAtCrankFromPneumatics;
+			var sum3 = _m7.SmartPneumaticOnlyAuxAirCompPowerGenAtCrank + _m6.AvgPowerDemandAtCrankFromElectricsIncHVAC;
+			var sum4 = _m6.AvgPowerDemandAtCrankFromElectricsIncHVAC + _m6.AveragePowerDemandAtCrankFromPneumatics;
+			var sw1 = _signals.SmartPneumatics ? sum1 : sum2;
+			var sw2 = _signals.SmartPneumatics ? sum3 : sum4;
+			var sw5 = _signals.SmartElectrics ? sw1 : sw2;
+			var sw6 = !_signals.EngineStopped;
+			var sum5 = _m1.AveragePowerDemandAtCrankFromHVACMechanicalsWatts() + sw5;
+			var sum6 = sw6 ? sum5 : 0.SI<Watt>();
+
+			var sw3 = _signals.SmartPneumatics ? _m7.SmartElectricalAndPneumaticAuxAltPowerGenAtCrank :
+				_m7.SmartElectricalOnlyAuxAltPowerGenAtCrank;
+
+			var sw4 = _signals.SmartElectrics ? _m6.SmartElecAndPneumaticsCompressorFlag : _m6.SmartPneumaticsOnlyCompressorFlag;
+
+			_auxPowerAtCrankFromElectricalHVACAndPneumaticsAncillaries = sum6;
+			_smartElectricalAlternatorPowerGenAtCrank = sw3;
+			_compressorFlag = sw4;
+		}
+
+		#region Implementation of IM8
+
+		public Watt AuxPowerAtCrankFromElectricalHVACAndPneumaticsAncillaries
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _auxPowerAtCrankFromElectricalHVACAndPneumaticsAncillaries; }
+		}
+
+		public Watt SmartElectricalAlternatorPowerGenAtCrank
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _smartElectricalAlternatorPowerGenAtCrank; }
+		}
+
+		public bool CompressorFlag
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _compressorFlag; }
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M09Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Hvac;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M09Impl : AbstractModule, IM9
+	{
+		
+		#region "Aggregates"
+
+		//'AG1
+		protected NormLiter _LitresOfAirCompressorOnContinuallyAggregate;
+
+		//'AG2
+		protected NormLiter _LitresOfAirCompressorOnOnlyInOverrunAggregate;
+
+		//'AG3
+		protected Kilogram _TotalCycleFuelConsumptionCompressorOffContinuouslyAggregate;
+
+		//'AG4
+		protected Kilogram _TotalCycleFuelConsumptionCompressorOnContinuouslyAggregate;
+
+		#endregion
+
+		protected IM1_AverageHVACLoadDemand M1;
+		protected IM4_AirCompressor M4;
+		protected IM6 M6;
+		protected IM8 M8;
+		protected IFuelConsumptionMap FMAP;
+		protected IPneumaticsAuxilliariesConfig PSAC;
+		protected ISignals Signals;
+
+		public M09Impl(IM1_AverageHVACLoadDemand m1, IM4_AirCompressor m4, IM6 m6, IM8 m8, IFuelConsumptionMap fmap, IPneumaticsAuxilliariesConfig psac, ISignals signals)
+		{
+			M1 = m1;
+			M4 = m4;
+			M6 = m6;
+			M8 = m8;
+			FMAP = fmap;
+			PSAC = psac;
+			Signals = signals;
+			ClearAggregates();
+		}
+
+
+		#region Implementation of IAuxiliaryEvent
+
+		public event IAuxiliaryEvent.AuxiliaryEventEventHandler AuxiliaryEvent;
+
+		#endregion
+
+		#region Implementation of IM9
+
+		public void ClearAggregates()
+		{
+			_LitresOfAirCompressorOnContinuallyAggregate = 0.SI<NormLiter>();
+			_LitresOfAirCompressorOnOnlyInOverrunAggregate = 0.SI<NormLiter>();
+			_TotalCycleFuelConsumptionCompressorOffContinuouslyAggregate = 0.SI<Kilogram>();
+			_TotalCycleFuelConsumptionCompressorOnContinuouslyAggregate = 0.SI<Kilogram>();
+		}
+
+		protected PerSecond S0(PerSecond rpm)
+		{
+			if (rpm < 1) {
+				rpm = 1.RPMtoRad();
+			}
+
+			return rpm;
+		}
+
+		public void CycleStep(Second stepTimeInSeconds)
+		{
+			if (Signals.EngineStopped) {
+				return;
+			}
+
+			var s9 = M6.OverrunFlag && M8.CompressorFlag ? M4.GetFlowRate() : 0.SI<NormLiterPerSecond>();
+			var s13 = Signals.ClutchEngaged && !(Signals.InNeutral) ? s9 : 0.SI<NormLiterPerSecond>();
+			var s10 = s13 * PSAC.OverrunUtilisationForCompressionFraction;
+
+			if (S0(Signals.EngineSpeed).IsEqual(0)) {
+				throw new DivideByZeroException("Engine speed is zero and cannot be used as a divisor.");
+			}
+
+			var s1 = M6.AvgPowerDemandAtCrankFromElectricsIncHVAC + M1.AveragePowerDemandAtCrankFromHVACMechanicalsWatts();
+			var s2 = M4.GetPowerCompressorOn() / S0(Signals.EngineSpeed);
+			var s3 = M4.GetPowerCompressorOff() / S0(Signals.EngineSpeed);
+			var s4 = s1 / S0(Signals.EngineSpeed);
+			var s14 = Signals.EngineDrivelineTorque +
+					Signals.PreExistingAuxPower / S0(Signals.EngineSpeed);
+			var s5 = s2 + s14;
+			var s6 = s14 + s3;
+			var s7 = s4 + s5;
+			var s8 = s4 + s6;
+
+			var int1 = FMAP.GetFuelConsumption(s7, Signals.EngineSpeed);
+			int1 = int1 > 0 && !double.IsNaN(int1.Value()) ? int1 : 0.SI<KilogramPerSecond>();
+			var s11 = int1;
+
+			var int2 = FMAP.GetFuelConsumption(s8, Signals.EngineSpeed);
+			int2 = int2 > 0 && !double.IsNaN(int2.Value()) ? int2 : 0.SI<KilogramPerSecond>();
+			var s12 = int2;
+
+			_LitresOfAirCompressorOnContinuallyAggregate += M4.GetFlowRate() * stepTimeInSeconds;
+			_LitresOfAirCompressorOnOnlyInOverrunAggregate += s10 * stepTimeInSeconds;
+			_TotalCycleFuelConsumptionCompressorOnContinuouslyAggregate += s11 * stepTimeInSeconds;
+			_TotalCycleFuelConsumptionCompressorOffContinuouslyAggregate += s12 * stepTimeInSeconds;
+		}
+
+		public NormLiter LitresOfAirCompressorOnContinually
+		{
+			get { return _LitresOfAirCompressorOnContinuallyAggregate; }
+		}
+
+		public NormLiter LitresOfAirCompressorOnOnlyInOverrun
+		{
+			get { return _LitresOfAirCompressorOnOnlyInOverrunAggregate; }
+		}
+
+		public Kilogram TotalCycleFuelConsumptionCompressorOnContinuously
+		{
+			get { return _TotalCycleFuelConsumptionCompressorOnContinuouslyAggregate; }
+		}
+
+		public Kilogram TotalCycleFuelConsumptionCompressorOffContinuously
+		{
+			get { return _TotalCycleFuelConsumptionCompressorOffContinuouslyAggregate; }
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M0_5Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules.Electrics;
+using VectoAuxiliaries.Electrics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M0_5Impl : AbstractModule, IM0_5_SmartAlternatorSetEfficiency
+	{
+		protected Ampere _smartIdleCurrent;
+		protected double _alternatorsEfficiencyIdleResultCard;
+		protected Ampere _smartTractionCurrent;
+		protected double _alternatorsEfficiencyTractionOnResultCard;
+		protected Ampere _smartOverrunCurrent;
+		protected double _alternatorsEfficiencyOverrunResultCard;
+		protected IM0_NonSmart_AlternatorsSetEfficiency _m0;
+		protected IElectricalConsumerList _electricalConsumables;
+		protected IAlternatorMap _alternatorMap;
+		protected IResultCard _resultCardIdle;
+		protected IResultCard _resultCardTraction;
+		protected IResultCard _resultCardOverrun;
+		protected ISignals _signals;
+
+		public M0_5Impl(IM0_NonSmart_AlternatorsSetEfficiency m0, IElectricalConsumerList electricalConsumables, IAlternatorMap alternatorMap, IResultCard resultCardIdle, IResultCard resultCardTraction, IResultCard resultCardOverrun, ISignals signals)
+		{
+			//'Sanity Check on supplied arguments, throw an argument exception
+			if (m0 == null) {
+				throw new ArgumentException("Module 0 must be supplied");}
+
+			if (electricalConsumables == null) {
+				throw new ArgumentException("ElectricalConsumablesList must be supplied even if empty");
+			}
+			if (alternatorMap ==null) {throw new ArgumentException("Must supply a valid alternator map");
+			}
+			if (resultCardIdle == null) {
+				throw new ArgumentException("Result Card 'IDLE' must be supplied even if it has no contents");
+			}
+
+			if (resultCardTraction == null) {
+				throw new ArgumentException("Result Card 'TRACTION' must be supplied even if it has no contents");
+			}
+
+			if (resultCardOverrun == null) {
+				throw new ArgumentException("Result Card 'OVERRUN' must be supplied even if it has no contents");
+			}
+			if (signals == null) {
+				throw new ArgumentException("No Signals Reference object was provided ");}
+
+			//'Assignments to private variables.
+			_m0 = m0;
+			_electricalConsumables = electricalConsumables;
+			_alternatorMap = alternatorMap;
+			_resultCardIdle = resultCardIdle;
+			_resultCardTraction = resultCardTraction;
+			_resultCardOverrun = resultCardOverrun;
+			_signals = signals;
+		}
+
+		#region Implementation of IM0_5_SmartAlternatorSetEfficiency
+
+		private Ampere HvacPlusNonBaseCurrents()
+		{
+			//'Stored Energy Efficience removed from V8.0 21/4/15 by Mike Preston  //tb
+			return _m0.GetHVACElectricalPowerDemandAmps + _electricalConsumables.GetTotalAverageDemandAmps(true);  //'/ElectricConstants.StoredEnergyEfficiency)
+		}
+
+		public Ampere SmartIdleCurrent
+		{
+			get {
+				var hvac_Plus_None_Base = HvacPlusNonBaseCurrents();
+				var smart_idle_current = _resultCardIdle.GetSmartCurrentResult(hvac_Plus_None_Base);
+
+				return smart_idle_current; 
+			}
+		}
+
+		public double AlternatorsEfficiencyIdleResultCard
+		{
+			get { return _alternatorMap.GetEfficiency(_signals.EngineSpeed.AsRPM, SmartIdleCurrent).Efficiency; }
+		}
+
+		public Ampere SmartTractionCurrent
+		{
+			get { return _resultCardTraction.GetSmartCurrentResult(HvacPlusNonBaseCurrents()); }
+		}
+
+		public double AlternatorsEfficiencyTractionOnResultCard
+		{
+			get { return _alternatorMap.GetEfficiency(_signals.EngineSpeed.AsRPM, SmartTractionCurrent).Efficiency; }
+		}
+
+		public Ampere SmartOverrunCurrent
+		{
+			get { return _resultCardOverrun.GetSmartCurrentResult(HvacPlusNonBaseCurrents()); }
+		}
+
+		public double AlternatorsEfficiencyOverrunResultCard
+		{
+			get { return _alternatorMap.GetEfficiency(_signals.EngineSpeed.AsRPM, SmartOverrunCurrent).Efficiency; }
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M10Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M10Impl : AbstractModule, IM10
+	{
+		protected Kilogram _averageLoadsFuelConsumptionInterpolatedForPneumatics;
+		protected Kilogram _fuelConsumptionSmartPneumaticsAndAverageElectricalPowerDemand;
+
+		protected IM3_AveragePneumaticLoadDemand M3;
+
+		protected IM9 M9;
+			//'Not Currently used but there for ease of refactoring in future.
+		protected ISignals Signals;
+
+		//'Aggregators
+		protected NormLiter _AverageAirConsumedLitre;
+
+		
+		public M10Impl(IM3_AveragePneumaticLoadDemand m3, IM9 m9, ISignals signals)
+		{
+			M3 = m3;
+			M9 = m9;
+			Signals = signals;
+			_AverageAirConsumedLitre = 0.SI<NormLiter>();
+		}
+
+		protected enum InterpolationType
+		{
+			NonSmartPneumtaics,
+			SmartPneumtaics
+		}
+
+		protected override void DoCalculate()
+		{
+			var intrp1 = Interpolate(InterpolationType.NonSmartPneumtaics);
+			var intrp2 = Interpolate(InterpolationType.SmartPneumtaics);
+
+			_averageLoadsFuelConsumptionInterpolatedForPneumatics = intrp1;
+			_fuelConsumptionSmartPneumaticsAndAverageElectricalPowerDemand = intrp2;
+		}
+
+		protected virtual Kilogram Interpolate(InterpolationType interpType)
+		{
+			var returnValue = 0.SI<Kilogram>();
+			//' Dim x1,y1,x2,y2,x3,y3, xTA As Single
+
+			var x1 = M9.LitresOfAirCompressorOnContinually;
+			var y1 = M9.TotalCycleFuelConsumptionCompressorOnContinuously;
+			var x2 = 0.SI<NormLiter>();
+			var y2 = M9.TotalCycleFuelConsumptionCompressorOffContinuously;
+			var x3 = M9.LitresOfAirCompressorOnOnlyInOverrun;
+			var y3 = M9.TotalCycleFuelConsumptionCompressorOffContinuously;
+			
+			var xTA = _AverageAirConsumedLitre;  //'m3.AverageAirConsumedPerSecondLitre
+
+			switch (interpType) {
+				// 'Non-Smart Pneumatics ( OUT 1 )
+				case InterpolationType.NonSmartPneumtaics:
+					//'returnValue = (y2 + (((y1 - y2) * xTA) / x1))
+					returnValue = VectoMath.Interpolate(x1, x2, y1, y2, xTA);
+					break;
+				// 'Smart Pneumatics ( OUT 2 )
+				case InterpolationType.SmartPneumtaics:
+					//'returnValue = (y3 + (((y1 - y3) / (x1 - x3)) * (xTA - x3)))
+					returnValue = VectoMath.Interpolate(x1, x3, y1, y3, xTA);
+					break;
+				default: throw new ArgumentOutOfRangeException(nameof(interpType), interpType, null);
+			}
+
+			return returnValue;
+		}
+
+		#region Implementation of IM10
+
+		public Kilogram AverageLoadsFuelConsumptionInterpolatedForPneumatics
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _averageLoadsFuelConsumptionInterpolatedForPneumatics; }
+		}
+
+		public Kilogram FuelConsumptionSmartPneumaticsAndAverageElectricalPowerDemand
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _fuelConsumptionSmartPneumaticsAndAverageElectricalPowerDemand; }
+		}
+
+		public void CycleStep(Second stepTimeInSeconds)
+		{
+			_AverageAirConsumedLitre += double.IsNaN(M3.AverageAirConsumedPerSecondLitre().Value()) ? 0.SI<NormLiter>() : M3.AverageAirConsumedPerSecondLitre() * stepTimeInSeconds;
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M11Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.Hvac;
+using VectoAuxiliaries.Pneumatics;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M11Impl : AbstractModule, IM11
+	{
+		protected Joule _smartElectricalTotalCycleElectricalEnergyGeneratedDuringOverrunOnly;
+		protected Joule _smartElectricalTotalCycleEletricalEnergyGenerated;
+		protected Joule _totalCycleElectricalDemand;
+		protected Kilogram _totalCycleFuelConsumptionSmartElectricalLoad;
+		protected Kilogram _totalCycleFuelConsumptionZeroElectricalLoad;
+		protected Joule _stopStartSensitiveTotalCycleElectricalDemand;
+		protected Kilogram _totalCycleFuelConsuptionAverageLoads;
+
+#region "Private Aggregates"
+		protected Joule AG1;
+		protected Joule AG2;
+		protected Joule AG3;
+		protected Kilogram AG4;
+		protected Kilogram AG5;
+		protected Joule AG6;
+		protected Kilogram AG7;
+#endregion
+
+		protected IM1_AverageHVACLoadDemand M1;
+		protected IM3_AveragePneumaticLoadDemand M3;
+		protected IM6 M6;
+		protected IM8 M8;
+		protected IFuelConsumptionMap FMAP;
+		protected ISignals Signals;
+
+		public M11Impl(IM1_AverageHVACLoadDemand m1, IM3_AveragePneumaticLoadDemand m3, IM6 m6, IM8 m8, IFuelConsumptionMap fmap, ISignals signals)
+		{
+			M1 = m1;
+			M3 = m3;
+			M6 = m6;
+			M8 = m8;
+			FMAP = fmap;
+			Signals = signals;
+			ClearAggregates();
+		}
+
+		#region Implementation of IM11
+
+		public Joule SmartElectricalTotalCycleElectricalEnergyGeneratedDuringOverrunOnly
+		{
+			get { return AG1; }
+		}
+
+		public Joule SmartElectricalTotalCycleEletricalEnergyGenerated
+		{
+			get { return AG2; }
+		}
+
+		public Joule TotalCycleElectricalDemand
+		{
+			get { return AG3; }
+		}
+
+		public Kilogram TotalCycleFuelConsumptionSmartElectricalLoad
+		{
+			get { return AG4; }
+		}
+
+		public Kilogram TotalCycleFuelConsumptionZeroElectricalLoad
+		{
+			get { return AG5; }
+		}
+
+		public Joule StopStartSensitiveTotalCycleElectricalDemand
+		{
+			get { return AG6; }
+		}
+
+		public Kilogram TotalCycleFuelConsuptionAverageLoads
+		{
+			get { return AG7; }
+		}
+
+		public void ClearAggregates()
+		{
+			AG1 = 0.SI<Joule>();
+			AG2 = 0.SI<Joule>();
+			AG3 = 0.SI<Joule>();
+			AG4 = 0.SI<Kilogram>();
+			AG5 = 0.SI<Kilogram>();
+			AG6 = 0.SI<Joule>();
+			AG7 = 0.SI<Kilogram>();
+		}
+
+		protected PerSecond Sum0(PerSecond rpm)
+		{
+			if (rpm < 1) {
+				rpm = 1.RPMtoRad();
+			}
+
+			return rpm; // ' / RPM_to_RadiansPerSecond
+		}
+
+		public void CycleStep(Second stepTimeInSeconds)
+		{
+			//'S/S Insensitive
+			AG3 += M6.AvgPowerDemandAtCrankFromElectricsIncHVAC * stepTimeInSeconds;
+
+
+			if (Signals.EngineStopped) {
+				return;
+			}
+
+			// 'S/S Sensitive
+			
+			var sum1 = M6.OverrunFlag ? M8.SmartElectricalAlternatorPowerGenAtCrank : 0.SI<Watt>();
+			AG1 += (sum1 * stepTimeInSeconds);
+			AG2 += (M8.SmartElectricalAlternatorPowerGenAtCrank * stepTimeInSeconds);
+
+			AG6 += (M6.AvgPowerDemandAtCrankFromElectricsIncHVAC * stepTimeInSeconds);
+
+			var sum2 = M3.GetAveragePowerDemandAtCrankFromPneumatics() + M1.AveragePowerDemandAtCrankFromHVACMechanicalsWatts();
+			var sum3 = M8.SmartElectricalAlternatorPowerGenAtCrank / Sum0(Signals.EngineSpeed);
+			var sum4 = sum2 / Sum0(Signals.EngineSpeed);
+			var sum9 = Signals.EngineDrivelineTorque +
+						(Signals.PreExistingAuxPower / Sum0(Signals.EngineSpeed));
+			var sum5 = sum4 + sum9;
+			var sum6 = sum3 + sum5;
+			var intrp1 = FMAP.GetFuelConsumption(sum6, Signals.EngineSpeed);
+			intrp1 = !double.IsNaN(intrp1.Value()) && intrp1 > 0 ? intrp1 : 0.SI<KilogramPerSecond>();
+			var sum7 = intrp1;
+
+			var intrp2 = FMAP.GetFuelConsumption(sum5, Signals.EngineSpeed);
+			intrp2 = !double.IsNaN(intrp2.Value()) && intrp2 > 0 ? intrp2 : 0.SI<KilogramPerSecond>();
+			var sum8 = intrp2;
+
+			var sum10 = M6.AvgPowerDemandAtCrankFromElectricsIncHVAC / Sum0(Signals.EngineSpeed);
+			var sum11 = sum5 + sum10;
+			var intrp3 = FMAP.GetFuelConsumption(sum11, Signals.EngineSpeed);
+			intrp3 = !double.IsNaN(intrp3.Value()) && intrp3 > 0 ? intrp3 : 0.SI<KilogramPerSecond>();
+			var sum12 = intrp3;
+
+			//'MQ: No longer needed - already per Second 'These need to be divided by 3600 as the Fuel
+			//	Map output is in Grams / Second.
+			AG4 += sum7 * stepTimeInSeconds; // '/ 3600
+			AG5 += sum8 * stepTimeInSeconds; // '  / 3600
+			AG7 += sum12 * stepTimeInSeconds; // '/ 3600
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M12Impl.cs

+using System;
+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M12Impl : AbstractModule, IM12
+	{
+		protected IM11 M11;
+		protected IM10 M10;
+		protected ISignals Signals;
+
+		protected Kilogram _fuelconsumptionwithsmartElectricsandAveragePneumaticPowerDemand;
+		protected Kilogram _baseFuelConsumptionWithTrueAuxiliaryLoads;
+		protected double _stopStartCorrection;
+
+		public M12Impl(IM10 m10, IM11 m11, ISignals signals)
+		{
+			M10 = m10;
+			M11 = m11;
+			Signals = signals;
+		}
+
+		private class Point
+		{
+			public Joule X;
+			public Kilogram Y;
+		}
+
+		protected override void DoCalculate()
+		{
+			var p1 = new Point { X = 0.SI<Joule>(), Y = M11.TotalCycleFuelConsumptionZeroElectricalLoad };
+			var p2 = new Point {
+				X = M11.SmartElectricalTotalCycleEletricalEnergyGenerated * Signals.StoredEnergyEfficiency,
+				Y = M11.TotalCycleFuelConsumptionSmartElectricalLoad
+			};
+
+			var ip5X = M11.TotalCycleElectricalDemand;
+			var tanTetaP2 = ((p2.Y - p1.Y).Value() / (p2.X - p1.X).Value());
+			var ip5yP2 = (p1.Y.Value() + (tanTetaP2 * ip5X.Value())).SI<Kilogram>();
+
+			var interp1 = double.IsNaN(ip5yP2.Value()) ? 0.SI<Kilogram>() : ip5yP2;
+
+			interp1 = !double.IsNaN(interp1.Value()) && M11.StopStartSensitiveTotalCycleElectricalDemand > 0
+				? interp1
+				: M11.TotalCycleFuelConsumptionZeroElectricalLoad;
+
+			_fuelconsumptionwithsmartElectricsandAveragePneumaticPowerDemand = interp1;
+
+			var p3 = new Point {
+				X = M11.StopStartSensitiveTotalCycleElectricalDemand,
+				Y = M10.AverageLoadsFuelConsumptionInterpolatedForPneumatics
+			};
+
+			var tanTetaP3 = (p3.Y - p1.Y).Value() / (p3.X - p1.X).Value();
+
+			var ip5yP3 = p1.Y + (tanTetaP3 * ip5X.Value()).SI<Kilogram>();
+
+			var interp2 = double.IsNaN(ip5yP3.Value()) ? 0.SI<Kilogram>() : ip5yP3;
+
+			interp2 = !double.IsNaN(interp2.Value()) && M11.StopStartSensitiveTotalCycleElectricalDemand > 0
+				? interp2
+				: M10.AverageLoadsFuelConsumptionInterpolatedForPneumatics;
+
+			_baseFuelConsumptionWithTrueAuxiliaryLoads = interp2;
+
+			var stopStartCorrectionV = _baseFuelConsumptionWithTrueAuxiliaryLoads /
+										(M10.AverageLoadsFuelConsumptionInterpolatedForPneumatics > 0
+											? M10.AverageLoadsFuelConsumptionInterpolatedForPneumatics
+											: 1.SI<Kilogram>());
+
+			_stopStartCorrection = stopStartCorrectionV > 0 ? stopStartCorrectionV.Value() : 1;
+		}
+
+
+		#region Implementation of IM12
+
+		public Kilogram FuelconsumptionwithsmartElectricsandAveragePneumaticPowerDemand
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _fuelconsumptionwithsmartElectricsandAveragePneumaticPowerDemand;
+			}
+		}
+
+		public Kilogram BaseFuelConsumptionWithTrueAuxiliaryLoads
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _baseFuelConsumptionWithTrueAuxiliaryLoads;
+			}
+		}
+
+		public double StopStartCorrection
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _stopStartCorrection;
+			}
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M13Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+
+
+	public class M13Impl : AbstractModule, IM13
+	{
+		protected IM10 M10;
+		protected IM11 M11;
+		protected IM12 M12;
+		protected ISignals Signals;
+
+		private Kilogram _whtcTotalCycleFuelConsumptionGrams;
+
+		public M13Impl(IM10 m10, IM11 m11, IM12 m12, ISignals signals)
+		{
+			M10 = m10;
+			M11 = m11;
+			M12 = m12;
+			Signals = signals;
+		}
+
+		protected override void DoCalculate()
+		{
+			var sum1 = M11.TotalCycleFuelConsuptionAverageLoads * M12.StopStartCorrection;
+			var sum2 = M10.AverageLoadsFuelConsumptionInterpolatedForPneumatics * M12.StopStartCorrection;
+			var sum3 = M10.FuelConsumptionSmartPneumaticsAndAverageElectricalPowerDemand * M12.StopStartCorrection;
+			var sum4 = -M12.FuelconsumptionwithsmartElectricsandAveragePneumaticPowerDemand + sum1;
+			var sum5 = sum2 - sum3;
+			var sum6 = M12.BaseFuelConsumptionWithTrueAuxiliaryLoads - sum4;
+			var sum7 = M12.BaseFuelConsumptionWithTrueAuxiliaryLoads - sum5;
+			var sum8 = -sum4 + sum7;
+			var sw1 = Signals.SmartPneumatics? sum8: sum6;
+			var sw2 = Signals.SmartPneumatics ? sum3 : M12.BaseFuelConsumptionWithTrueAuxiliaryLoads;
+			var sw3 = Signals.SmartElectrics? sw1: sw2;
+			var sw4 = Signals.DeclarationMode ? Signals.WHTC : 1;
+			var sum9 = sw4 * sw3;
+
+			_whtcTotalCycleFuelConsumptionGrams = sum9;
+		}
+
+		#region Implementation of IM13
+
+		public Kilogram WHTCTotalCycleFuelConsumptionGrams
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _whtcTotalCycleFuelConsumptionGrams; }
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M14Impl.cs

+using TUGraz.VectoCommon.Utils;
+using VectoAuxiliaries;
+using VectoAuxiliaries.DownstreamModules;
+using VectoAuxiliaries.DownstreamModules.HVAC;
+using VectoAuxiliaries.Hvac;
+
+namespace TUGraz.VectoCore.BusAuxiliaries.DownstreamModules.Impl
+{
+	public class M14Impl : AbstractModule, IM14
+	{
+		protected IM13 M13;
+		protected ISignals Signals;
+		protected IHVACConstants Constants;
+		protected ISSMTOOL SSM;
+
+		protected Kilogram _totalCycleFcGrams;
+		protected Liter _totalCycleFcLitres;
+
+		public M14Impl(IM13 m13, ISSMTOOL ssm, IHVACConstants hvacConstants, ISignals signals)
+		{
+			M13 = m13;
+			SSM = ssm;
+			Constants = hvacConstants;
+			Signals = signals;
+		}
+
+
+		protected override void DoCalculate()
+		{
+			var s1 = M13.WHTCTotalCycleFuelConsumptionGrams * Constants.DieselGCVJperGram;
+			var s2 = SSM.GenInputs.AH_FuelEnergyToHeatToCoolant * s1;
+			var s3 = s2 * SSM.GenInputs.AH_CoolantHeatTransferredToAirCabinHeater;
+			var s4 = s3 / Signals.CurrentCycleTimeInSeconds.SI<Second>();
+			var s5 = Signals.CurrentCycleTimeInSeconds.SI<Second>(); // ' / 3600
+			var s6 = (s5 * SSM.FuelPerHBaseAsjusted(s4.Value() / 1000).SI(Unit.SI.Liter.Per.Hour)).Cast<Liter>() * Constants.FuelDensity;
+			var s7 = M13.WHTCTotalCycleFuelConsumptionGrams + s6;
+			var s8 = (s7 / (Constants.FuelDensity)).Cast<Liter>();
+			_totalCycleFcGrams = s7;
+			_totalCycleFcLitres = s8;
+			
+		}
+
+
+		#region Implementation of IM14
+
+		public Kilogram TotalCycleFCGrams
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _totalCycleFcGrams;
+			}
+		}
+
+		public Liter TotalCycleFCLitres
+		{
+			get {
+				if (!calculationValid) {
+					Calculate();
+				}
+				return _totalCycleFcLitres;
+			}
+		}
+
+		#endregion
+	}
+}

VECTOAux/BusAuxiliaries/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("BusAuxiliaries")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("BusAuxiliaries")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("550d99d4-25f7-48d9-b0f0-e5dd6cb3485d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]