From 143f3da9f78c7fcab70f25e5648ccebadf78bbaf Mon Sep 17 00:00:00 2001
From: Markus Quaritsch <markus.quaritsch@tugraz.at>
Date: Thu, 19 Sep 2019 14:23:43 +0200
Subject: [PATCH] refactoring: implementing BusAuxModules in new C# project
---
VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj | 81 ++++++++
.../DownstreamModules/Impl/AbstractModule.cs | 25 +++
.../DownstreamModules/Impl/M00Impl.cs | 77 ++++++++
.../DownstreamModules/Impl/M01Impl.cs | 98 ++++++++++
.../DownstreamModules/Impl/M02Impl.cs | 61 ++++++
.../DownstreamModules/Impl/M03Impl.cs | 141 ++++++++++++++
.../DownstreamModules/Impl/M04Impl.cs | 100 ++++++++++
.../DownstreamModules/Impl/M05Impl.cs | 55 ++++++
.../DownstreamModules/Impl/M06Impl.cs | 173 ++++++++++++++++++
.../DownstreamModules/Impl/M07Impl.cs | 94 ++++++++++
.../DownstreamModules/Impl/M08Impl.cs | 83 +++++++++
.../DownstreamModules/Impl/M09Impl.cs | 136 ++++++++++++++
.../DownstreamModules/Impl/M0_5Impl.cs | 105 +++++++++++
.../DownstreamModules/Impl/M10Impl.cs | 105 +++++++++++
.../DownstreamModules/Impl/M11Impl.cs | 152 +++++++++++++++
.../DownstreamModules/Impl/M12Impl.cs | 111 +++++++++++
.../DownstreamModules/Impl/M13Impl.cs | 58 ++++++
.../DownstreamModules/Impl/M14Impl.cs | 68 +++++++
.../BusAuxiliaries/Properties/AssemblyInfo.cs | 36 ++++
19 files changed, 1759 insertions(+)
create mode 100644 VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/AbstractModule.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M00Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M01Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M02Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M03Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M04Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M05Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M06Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M07Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M08Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M09Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M0_5Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M10Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M11Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M12Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M13Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M14Impl.cs
create mode 100644 VECTOAux/BusAuxiliaries/Properties/AssemblyInfo.cs
diff --git a/VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj b/VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj
new file mode 100644
index 0000000000..e1c35c9c30
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/BusAuxiliaries.csproj
@@ -0,0 +1,81 @@
+<?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
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/AbstractModule.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/AbstractModule.cs
new file mode 100644
index 0000000000..8eb867e312
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/AbstractModule.cs
@@ -0,0 +1,25 @@
+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() { }
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M00Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M00Impl.cs
new file mode 100644
index 0000000000..f0d4272287
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M00Impl.cs
@@ -0,0 +1,77 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M01Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M01Impl.cs
new file mode 100644
index 0000000000..d275331ca4
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M01Impl.cs
@@ -0,0 +1,98 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M02Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M02Impl.cs
new file mode 100644
index 0000000000..517cfb97eb
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M02Impl.cs
@@ -0,0 +1,61 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M03Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M03Impl.cs
new file mode 100644
index 0000000000..004080d3a9
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M03Impl.cs
@@ -0,0 +1,141 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M04Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M04Impl.cs
new file mode 100644
index 0000000000..76ab64701c
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M04Impl.cs
@@ -0,0 +1,100 @@
+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);
+ }
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M05Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M05Impl.cs
new file mode 100644
index 0000000000..a4af601f2a
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M05Impl.cs
@@ -0,0 +1,55 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M06Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M06Impl.cs
new file mode 100644
index 0000000000..37afc61473
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M06Impl.cs
@@ -0,0 +1,173 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M07Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M07Impl.cs
new file mode 100644
index 0000000000..4c897e1669
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M07Impl.cs
@@ -0,0 +1,94 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M08Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M08Impl.cs
new file mode 100644
index 0000000000..37a899b30b
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M08Impl.cs
@@ -0,0 +1,83 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M09Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M09Impl.cs
new file mode 100644
index 0000000000..162f4fbea6
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M09Impl.cs
@@ -0,0 +1,136 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M0_5Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M0_5Impl.cs
new file mode 100644
index 0000000000..6a22571a85
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M0_5Impl.cs
@@ -0,0 +1,105 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M10Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M10Impl.cs
new file mode 100644
index 0000000000..8bd326904d
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M10Impl.cs
@@ -0,0 +1,105 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M11Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M11Impl.cs
new file mode 100644
index 0000000000..c24717ee08
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M11Impl.cs
@@ -0,0 +1,152 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M12Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M12Impl.cs
new file mode 100644
index 0000000000..ae8c057645
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M12Impl.cs
@@ -0,0 +1,111 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M13Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M13Impl.cs
new file mode 100644
index 0000000000..b6e08d7031
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M13Impl.cs
@@ -0,0 +1,58 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M14Impl.cs b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M14Impl.cs
new file mode 100644
index 0000000000..04ca5e2985
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/DownstreamModules/Impl/M14Impl.cs
@@ -0,0 +1,68 @@
+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
+ }
+}
diff --git a/VECTOAux/BusAuxiliaries/Properties/AssemblyInfo.cs b/VECTOAux/BusAuxiliaries/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000000..0efaa050d3
--- /dev/null
+++ b/VECTOAux/BusAuxiliaries/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+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")]
--
GitLab