AirmassVeModelBase Class Reference

#include <airmass.h>

Inheritance diagram for AirmassVeModelBase:

Collaboration diagram for AirmassVeModelBase:

Public Member Functions
	AirmassVeModelBase (const ValueProvider3D &veTable)
float	getVe (float rpm, percent_t load, bool postState) const
Public Member Functions inherited from AirmassModelBase
virtual AirmassResult	getAirmass (float rpm, bool postState)=0

Private Attributes
const ValueProvider3D *const	m_veTable

Detailed Description

Definition at line 15 of file airmass.h.

Constructor & Destructor Documentation

AirmassVeModelBase()

AirmassVeModelBase::AirmassVeModelBase ( const ValueProvider3D &  veTable )

explicit

Definition at line 6 of file airmass.cpp.

: m_veTable(&veTable) {}

Member Function Documentation

getVe()

float AirmassVeModelBase::getVe	(	float	rpm,
		percent_t	load,
		bool	postState
	)		const

Definition at line 17 of file airmass.cpp.

                                                                           {
    efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_veTable != nullptr, "VE table null", 0);
 
    // Override the load value if necessary
    load = getVeLoadAxis(engineConfiguration->veOverrideMode, load);
 
    percent_t ve = m_veTable->getValue(rpm, load);
    float idleVeLoad = load;
 
#if EFI_IDLE_CONTROL
    auto tps = Sensor::get(SensorType::Tps1);
    // get VE from the separate table for Idle if idling
    if (engine->module<IdleController>()->isIdlingOrTaper() &&
        tps && engineConfiguration->useSeparateVeForIdle) {
        idleVeLoad = getVeLoadAxis(engineConfiguration->idleVeOverrideMode, load);
 
        percent_t idleVe = interpolate3d(
            config->idleVeTable,
            config->idleVeLoadBins, idleVeLoad,
            config->idleVeRpmBins, rpm
        );
 
        // interpolate between idle table and normal (running) table using TPS threshold
        // 0 TPS -> idle table
        // 1/2 threshold -> idle table
        // idle threshold -> normal table
        float idleThreshold = engineConfiguration->idlePidDeactivationTpsThreshold;
        ve = interpolateClamped(idleThreshold / 2, idleVe, idleThreshold, ve, tps.Value);
    }
#endif // EFI_IDLE_CONTROL
 
    // Add any adjustments if configured
    for (size_t i = 0; i < efi::size(config->veBlends); i++) {
        auto result = calculateBlend(config->veBlends[i], rpm, load);
 
        if (postState) {
            engine->outputChannels.veBlendParameter[i] = result.BlendParameter;
            engine->outputChannels.veBlendBias[i] = result.Bias;
            engine->outputChannels.veBlendOutput[i] = result.Value;
            engine->outputChannels.veBlendYAxis[i] = result.TableYAxis;
        }
 
        // Skip extra floating point math if we can...
        if (result.Value == 0) {
            continue;
        }
 
        // Apply as a multiplier, not as an adder
        // Value of +5 means add 5%, aka multiply by 1.05
        ve *= ((100 + result.Value) * 0.01f);
    }
 
    if (postState) {
        engine->engineState.currentVe = ve;
        engine->engineState.veTableYAxis = load;
        engine->engineState.veTableIdleYAxis = idleVeLoad;
    }
 
    return ve * PERCENT_DIV;
}

Referenced by AlphaNAirmass::getAirmass(), SpeedDensityAirmass::getAirmass(), and MafAirmass::getAirmassImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_veTable

const ValueProvider3D* const AirmassVeModelBase::m_veTable

private

Definition at line 23 of file airmass.h.

Referenced by getVe().

---

The documentation for this class was generated from the following files:

• controllers/algo/airmass/airmass.h
• controllers/algo/airmass/airmass.cpp