Code development platform for open source projects from the European Union institutions :large_blue_circle: EU Login authentication by SMS has been phased out. To see alternatives please check here

Skip to content
Snippets Groups Projects
Commit 143f3da9 authored by Markus Quaritsch's avatar Markus Quaritsch
Browse files

refactoring: implementing BusAuxModules in new C# project

parent b9e53ce6
Branches
Tags
No related merge requests found
Showing
with 1759 additions and 0 deletions
<?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
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() { }
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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);
}
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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
}
}
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")]
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment