#include <speed_density_airmass.h>

Inheritance diagram for SpeedDensityAirmass:

[legend]

Collaboration diagram for SpeedDensityAirmass:

[legend]

Public Member Functions
	SpeedDensityAirmass (const ValueProvider3D &veTable, const ValueProvider3D &mapEstimationTable)

AirmassResult	getAirmass (float rpm, bool postState) override

AirmassResult	getAirmass (float rpm, float map, bool postState)

float	getAirflow (float rpm, float map, bool postState)

float	getMap (float rpm, bool postState)

Public Member Functions inherited from AirmassVeModelBase
	AirmassVeModelBase (const ValueProvider3D &veTable)

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

Private Member Functions
float	getPredictiveMap (float rpm, bool postState, float mapSensor)

float	logAndGetFallback (float rpm, bool postState) const

Private Attributes
const ValueProvider3D *const	m_mapEstimationTable

bool	m_isMapPredictionActive = false

Timer	m_predictionTimer

float	m_initialPredictedMap = 0

float	m_initialRealMap = 0

Additional Inherited Members
Static Public Member Functions inherited from SpeedDensityBase
static mass_t	getAirmassImpl (float ve, float manifoldPressure, float temperature)

Protected Member Functions inherited from SpeedDensityBase
	SpeedDensityBase (const ValueProvider3D &veTable)

Detailed Description

Definition at line 6 of file speed_density_airmass.h.

Constructor & Destructor Documentation

◆ SpeedDensityAirmass()

SpeedDensityAirmass::SpeedDensityAirmass	(	const ValueProvider3D &	veTable,
		const ValueProvider3D &	mapEstimationTable
	)

inlineexplicit

Definition at line 8 of file speed_density_airmass.h.

        : SpeedDensityBase(veTable)
        , m_mapEstimationTable(&mapEstimationTable)
    {}

Member Function Documentation

◆ getAirflow()

float SpeedDensityAirmass::getAirflow	(	float	rpm,
		float	map,
		bool	postState
	)

Definition at line 41 of file speed_density_airmass.cpp.

                                                                          {
    auto airmassResult = getAirmass(rpm, map, postState);
 
    float massPerCycle = airmassResult.CylinderAirmass * engineConfiguration->cylindersCount;
 
    if (!engineConfiguration->twoStroke) {
        // 4 stroke engines only do a half cycle per rev
        massPerCycle = massPerCycle / 2;
    }
 
    // g/s
    return massPerCycle * rpm / 60;
}

Referenced by getMaxAirflowAtMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAirmass() [1/2]

AirmassResult SpeedDensityAirmass::getAirmass	(	float	rpm,
		bool	postState
	)

overridevirtual

Implements AirmassModelBase.

Definition at line 6 of file speed_density_airmass.cpp.

                                                                       {
    ScopePerf perf(PE::GetSpeedDensityFuel);
 
    auto map = getMap(rpm, postState);
 
    return getAirmass(rpm, map, postState);
}

Referenced by getAirflow(), and getAirmass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAirmass() [2/2]

AirmassResult SpeedDensityAirmass::getAirmass	(	float	rpm,
		float	map,
		bool	postState
	)

most of the values are pre-calculated for performance reasons

Definition at line 14 of file speed_density_airmass.cpp.

                                                                                  {
    /**
     * most of the values are pre-calculated for performance reasons
     */
    float tChargeK = engine->engineState.sd.tChargeK;
    if (std::isnan(tChargeK)) {
        warning(ObdCode::CUSTOM_ERR_TCHARGE_NOT_READY2, "tChargeK not ready"); // this would happen before we have CLT reading for example
        return {};
    }
 
    float ve = getVe(rpm, map, postState);
 
    float airMass = getAirmassImpl(ve, map, tChargeK);
    if (std::isnan(airMass)) {
        warning(ObdCode::CUSTOM_ERR_6685, "NaN airMass");
        return {};
    }
#if EFI_PRINTF_FUEL_DETAILS
    printf("getSpeedDensityAirmass map=%.2f\n", map);
#endif /*EFI_PRINTF_FUEL_DETAILS */
 
    return {
        airMass,
        map,    // AFR/VE table Y axis
    };
}

Here is the call graph for this function:

◆ getMap()

float SpeedDensityAirmass::getMap	(	float	rpm,
		bool	postState
	)

Definition at line 114 of file speed_density_airmass.cpp.

                                                           {
  auto mapSensor = Sensor::get(SensorType::Map);
    if (mapSensor && engineConfiguration->accelEnrichmentMode == AE_MODE_PREDICTIVE_MAP) {
        return getPredictiveMap(rpm, postState, mapSensor.Value);
    }
    return mapSensor.value_or(logAndGetFallback(rpm, postState));
}

Referenced by getAirmass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPredictiveMap()

float SpeedDensityAirmass::getPredictiveMap	(	float	rpm,
		bool	postState,
		float	mapSensor
	)

private

Definition at line 55 of file speed_density_airmass.cpp.

                                                                                      {
    float blendDuration = interpolate2d(rpm, config->predictiveMapBlendDurationBins,
                        config->predictiveMapBlendDurationValues);
 
    float elapsedTime = m_predictionTimer.getElapsedSeconds();
 
    if (m_isMapPredictionActive && elapsedTime >= blendDuration) {
            // prediction phase is over
            m_isMapPredictionActive = false;
    }
 
    float effectiveMap = 0;
    if (m_isMapPredictionActive) {
        float blendFactor = elapsedTime / blendDuration;
        // Linearly interpolate between the initial predicted and real values
        effectiveMap = m_initialPredictedMap + (m_initialRealMap - m_initialPredictedMap) * blendFactor;
 
        if (mapSensor >= effectiveMap) {
            m_isMapPredictionActive = false;
        }
    } else {
        if (engine->module<TpsAccelEnrichment>()->isAccelEventTriggered()) {
            float predictedMap = logAndGetFallback(rpm, postState);
 
            if (predictedMap > mapSensor) {
                m_isMapPredictionActive = true;
              engine->module<TpsAccelEnrichment>()->m_timeSinceAccel.reset();
                m_predictionTimer.reset();
                m_initialPredictedMap = predictedMap;
                m_initialRealMap = mapSensor;
                effectiveMap = predictedMap;
            }
        }
    }
  engine->outputChannels.isMapPredictionActive = m_isMapPredictionActive;
 
    if (!m_isMapPredictionActive) {
        effectiveMap = mapSensor;
    }
 
#if EFI_TUNER_STUDIO
    if (postState) {
        engine->outputChannels.effectiveMap = effectiveMap;
    }
#endif // EFI_TUNER_STUDIO
 
    return effectiveMap;
}

Referenced by getMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logAndGetFallback()

float SpeedDensityAirmass::logAndGetFallback	(	float	rpm,
		bool	postState
	)		const

private

Definition at line 104 of file speed_density_airmass.cpp.

                                                                            {
  float fallbackMap = m_mapEstimationTable->getValue(rpm, Sensor::getOrZero(SensorType::Tps1));
#if EFI_TUNER_STUDIO
    if (postState) {
        engine->outputChannels.fallbackMap = fallbackMap;
    }
#endif // EFI_TUNER_STUDIO
  return fallbackMap;
}