#include <orea/scenario/scenarioshiftcalculator.hpp>

Collaboration diagram for ScenarioShiftCalculator:

Public Member Functions
	ScenarioShiftCalculator (const QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData > &sensitivityConfig, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &simMarketConfig, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &simMarket=QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket >())

QuantLib::Real	shift (const ore::analytics::RiskFactorKey &key, const ore::analytics::Scenario &s_1, const ore::analytics::Scenario &s_2) const

Private Member Functions
QuantLib::Real	transform (const ore::analytics::RiskFactorKey &key, QuantLib::Real value, const QuantLib::Date &asof) const

Private Attributes
QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData >	sensitivityConfig_

QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters >	simMarketConfig_

QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket >	simMarket_

Detailed Description

Class for calculating the shift multiple between two scenarios for a given risk factor key.

The shift value returned is a value that is consistent with the SensitivityScenarioData and ScenarioSimMarketParameters passed in during construction. In other words, multiplying the result of the shift method with sensitivities generated using the SensitivityScenarioData configuration will give a valid estimate of the P&L move associated with moving from one scenario to another.

Definition at line 41 of file scenarioshiftcalculator.hpp.

Constructor & Destructor Documentation

◆ ScenarioShiftCalculator()

ScenarioShiftCalculator	(	const QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData > &	sensitivityConfig,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &	simMarketConfig,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &	simMarket = `QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarket>()`
	)

Constructor

Parameters

sensitivityConfig	sensitivity configuration that will determine the result returned by the shift method
simMarketConfig	simulation market configuration for the scenarios that will be fed to the shift method
simMarket	simulation market that will be used if provided

Definition at line 44 of file scenarioshiftcalculator.cpp.

47 : sensitivityConfig_(sensitivityConfig), simMarketConfig_(simMarketConfig), simMarket_(simMarket) {}

ore::analytics::ScenarioShiftCalculator::simMarketConfig_

QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > simMarketConfig_

Definition: scenarioshiftcalculator.hpp:62

ore::analytics::ScenarioShiftCalculator::sensitivityConfig_

QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData > sensitivityConfig_

Definition: scenarioshiftcalculator.hpp:61

ore::analytics::ScenarioShiftCalculator::simMarket_

QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > simMarket_

Definition: scenarioshiftcalculator.hpp:63

Member Function Documentation

◆ shift()

Real shift	(	const ore::analytics::RiskFactorKey &	key,
		const ore::analytics::Scenario &	s_1,
		const ore::analytics::Scenario &	s_2
	)		const

Calculate the shift in the risk factor key implied by going from scenario s_1 to scenario s_2.

Definition at line 49 of file scenarioshiftcalculator.cpp.

                                                                                                            {
 
    // Get the respective (transformed) scenario values
    Real v_1 = transform(key, s_1.get(key), s_1.asof());
    Real v_2 = transform(key, s_2.get(key), s_2.asof());
 
    // If for any reason v_1 or v_2 are not finite or nan, log an alert and return 0
    if (!std::isfinite(v_1) || std::isnan(v_1)) {
        ALOG("The scenario value v_1 for key '" << key << "' is " << v_1 << " and is not usable so we are returning 0");
        return 0.0;
    }
    if (!std::isfinite(v_2) || std::isnan(v_2)) {
        ALOG("The scenario value v_2 for key '" << key << "' is " << v_2 << " and is not usable so we are returning 0");
        return 0.0;
    }
 
    // Get the shift size and type from the sensitivity configuration
    const ShiftData& shiftData = sensitivityConfig_->shiftData(key.keytype, key.name);
    Real shiftSize = shiftData.shiftSize;
    ShiftType shiftType = shiftData.shiftType;
 
    // If shiftSize is zero, log an alert and return 0 early
    if (close(shiftSize, 0.0)) {
        ALOG("The shift size for key '" << key << "' in sensitivity config is zero");
        return 0.0;
    }
 
    // Get the multiple of the sensitivity shift size in moving from scenario 1 to 2
    Real result = 0.0;
    if (shiftType == ShiftType::Absolute) {
        result = v_2 - v_1;
    } else {
        if (close(v_1, 0.0)) {
            ALOG("The reference scenario value for key '"
                 << key << "' is zero and the shift is relative so must return a shift of zero");
        } else {
            result = v_2 / v_1 - 1.0;
        }
    }
    result /= shiftSize;
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transform()

Real transform	(	const ore::analytics::RiskFactorKey &	key,
		QuantLib::Real	value,
		const QuantLib::Date &	asof
	)		const

private

For some risk factors, the sensitivty is understood to be to a transform of the quantity that appears in the scenario and this transform can generally require the time to expiry of the factor.

For example, the SensitivityScenarioData expresses shifts for IR in terms of zero rates and the scenarios hold discount factors so to convert the scenario value from \(df_t\) to \(z_t\), you need to know the year fraction until maturity i.e. \(\tau(0, t)\) and then the transformed value is:

\[ z_t = - \frac{\ln(df_t)}{\tau(0, t)} \]

Definition at line 93 of file scenarioshiftcalculator.cpp.

                                                                                                    {
 
    Period p;
    DayCounter dc = Actual365Fixed();
 
    switch (key.keytype) {
    case RFType::DiscountCurve:
    case RFType::YieldCurve:
    case RFType::IndexCurve:
        p = simMarketConfig_->yieldCurveTenors(key.name).at(key.index);
        if (simMarket_)
            dc = simMarket_->iborIndex(key.name)->forwardingTermStructure()->dayCounter();
        break;
    case RFType::DividendYield:
        p = simMarketConfig_->equityDividendTenors(key.name).at(key.index);
        if (simMarket_)
            dc = simMarket_->equityDividendCurve(key.name)->dayCounter();
        break;
    case RFType::SurvivalProbability:
        p = simMarketConfig_->defaultTenors(key.name).at(key.index);
        if (simMarket_)
            dc = simMarket_->defaultCurve(key.name)->curve()->dayCounter();
        break;
    default:
        // If we get to here, return untransformed value
        return value;
        break;
    }
 
    // If we get to here, calculate transformed value
    Time t = dc.yearFraction(asof, asof + p);
 
    // The way that this is used above should be ok i.e. will always be 0 - 0 when t = 0
    if (close(t, 0.0)) {
        ALOG("The time needed in the denominator of the transform for key '"
             << key << "' is zero so we return a transformed value of zero");
        return 0.0;
    }
 
    return -log(value) / t;
}