Convert all par shifts in a single stress test scenario to zero shifts. More...

#include <orea/engine/parstressscenarioconverter.hpp>

Collaboration diagram for ParStressScenarioConverter:

Public Member Functions
	ParStressScenarioConverter (const QuantLib::Date &asof, const std::vector< RiskFactorKey > &sortedParInstrumentRiskFactorKeys, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &simMarketParams, const QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData > &sensiScenarioData, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &simMarket, const ore::analytics::ParSensitivityInstrumentBuilder::Instruments &parInstruments, bool useSpreadedTermStructure)

ore::analytics::StressTestScenarioData::StressTestData	convertScenario (const StressTestScenarioData::StressTestData &scenario) const
	Convert par shifts in a stress scenario to zero shifts. More...

Private Member Functions
bool	scenarioCanBeConverted (const StressTestScenarioData::StressTestData &parStressScenario) const
	check if the scenario can be converted More...

double	maturityTime (const RiskFactorKey &key) const
	compute the time to tenor of the risk factor key More...

std::pair< size_t, size_t >	getCapFloorTenorAndStrikeIds (const RiskFactorKey &rfKey) const
	get the strike and tenor from a optionlet riskfactor key More...

double	shiftsSizeForScenario (const RiskFactorKey rfKey, double targetValue, double baseValue) const
	convert the scenario value to the corresponding zero shift size for the stress test data More...

void	updateTargetStressTestScenarioData (StressTestScenarioData::StressTestData &stressScenario, const RiskFactorKey &key, const double zeroShift) const
	add zero shifts in the stress test data More...

double	impliedParRate (const RiskFactorKey &key) const
	Compute the implied fair rate of the par instrument. More...

double	getStressShift (const RiskFactorKey &key, const StressTestScenarioData::StressTestData &stressScenario) const
	get the par stress shift size from stress test data More...

double	lowerBound (const RiskFactorKey key) const

double	upperBound (const RiskFactorKey key) const

Private Attributes
QuantLib::Date	asof_

const std::vector< RiskFactorKey >	sortedParInstrumentRiskFactorKeys_

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

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

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

const ore::analytics::ParSensitivityInstrumentBuilder::Instruments &	parInstruments_

bool	useSpreadedTermStructure_ = true

double	minVol_ = 1e-8

double	maxVol_ = 10.0

double	minDiscountFactor_ = 1e-8

double	maxDiscountFactor_ = 10.0

double	accuracy_ = 1e-8

Detailed Description

Convert all par shifts in a single stress test scenario to zero shifts.

Definition at line 43 of file parstressscenarioconverter.hpp.

Constructor & Destructor Documentation

◆ ParStressScenarioConverter()

ParStressScenarioConverter	(	const QuantLib::Date &	asof,
		const std::vector< RiskFactorKey > &	sortedParInstrumentRiskFactorKeys,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &	simMarketParams,
		const QuantLib::ext::shared_ptr< ore::analytics::SensitivityScenarioData > &	sensiScenarioData,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &	simMarket,
		const ore::analytics::ParSensitivityInstrumentBuilder::Instruments &	parInstruments,
		bool	useSpreadedTermStructure
	)

Definition at line 313 of file parstressscenarioconverter.cpp.

    : asof_(asof), sortedParInstrumentRiskFactorKeys_(sortedParInstrumentRiskFactorKeys),
      simMarketParams_(simMarketParams), sensiScenarioData_(sensiScenarioData), simMarket_(simMarket),
      parInstruments_(parInstruments), useSpreadedTermStructure_(useSpreadedTermStructure) {}

Member Function Documentation

◆ convertScenario()

ore::analytics::StressTestScenarioData::StressTestData convertScenario ( const StressTestScenarioData::StressTestData & scenario ) const

Convert par shifts in a stress scenario to zero shifts.

Definition at line 324 of file parstressscenarioconverter.cpp.

                                                                                                               {
 
    if (!parStressScenario.containsParShifts()) {
        return parStressScenario;
    }
 
    if (!scenarioCanBeConverted(parStressScenario)) {
        WLOG("Can not convert scenario " << parStressScenario.label << " Skip it and apply all shifts as zero shifts.");
        return parStressScenario;
    }
 
    simMarket_->reset();
 
    LOG("ParStressConverter: Scenario " << parStressScenario.label << " has IR Curve Par Shifts = "
                                        << ore::data::to_string(parStressScenario.irCurveParShifts));
 
    LOG("ParStressConverter: Scenario " << parStressScenario.label << " has CapFloor Par Shifts = "
                                        << ore::data::to_string(parStressScenario.irCapFloorParShifts));
 
    LOG("ParStressConverter: Scenario " << parStressScenario.label << " has Credit Par Shifts = "
                                        << ore::data::to_string(parStressScenario.creditCurveParShifts));
 
    std::set<RiskFactorKey::KeyType> excludedParRates =
        disabledParRates(parStressScenario.irCurveParShifts, parStressScenario.irCapFloorParShifts,
                         parStressScenario.creditCurveParShifts);
 
    LOG("ParStressConverter: Copy scenario and remove parShifts from scenario");
    auto zeroStressScenario = removeParShiftsCopy(parStressScenario);
    DLOG("ParStressConverter: Clone base scenario");
    auto zeroSimMarketScenario = simMarket_->baseScenario()->clone();
 
    // Derive t0 (unshifted) fair Rates
    std::vector<RiskFactorKey> relevantParKeys;
    std::map<RiskFactorKey, double> fairRates;
    std::map<RiskFactorKey, double> baseScenarioValues;
    std::map<RiskFactorKey, double> targets;
    LOG("ParStressConverter: Compute fair rate and target rate for all ParInstruments");
    for (const auto& rfKey : sortedParInstrumentRiskFactorKeys_) {
        if (excludedParRates.count(rfKey.keytype) == 0 &&
            (supportedCurveShiftTypes.count(rfKey.keytype) == 1 ||
             rfKey.keytype == RiskFactorKey::KeyType::OptionletVolatility)) {
            relevantParKeys.push_back(rfKey);
            const double fairRate = impliedParRate(rfKey);
            // TODO get shift type;
            const double target =
                computeTargetRate(fairRate, getStressShift(rfKey, parStressScenario), ShiftType::Absolute);
            const double baseScenarioValue = simMarket_->baseScenario()->get(rfKey);
            const double baseScenarioAbsoluteValue = simMarket_->baseScenarioAbsolute()->get(rfKey);
            DLOG("ParStressConverter:  ParInstrument "
                 << rfKey << ", fair rate = " << fairRate << ", target rate = " << target << ", baseScenarioValue  = "
                 << baseScenarioValue << ", baseScenarioAbsoluteValue = " << baseScenarioAbsoluteValue);
            fairRates[rfKey] = fairRate;
            targets[rfKey] = target;
            baseScenarioValues[rfKey] = baseScenarioValue;
        } else {
            DLOG("Skip parInsturment " << rfKey << " the shifts for this risk factor type are in zero domain.");
        }
    }
    // Optimize IR curves and Credit curves
    LOG("ParStressConverter: Imply zero shifts");
    std::map<RiskFactorKey, double> shifts;
    for (const auto& rfKey : relevantParKeys) {
        DLOG("Imply zero shifts for parInstrument " << rfKey);
        const double target = targets[rfKey];
        auto targetFunction = [this, &target, &rfKey, &zeroSimMarketScenario](double x) {
            zeroSimMarketScenario->add(rfKey, x);
            simMarket_->applyScenario(zeroSimMarketScenario);
            return (impliedParRate(rfKey) - target) * 1e6;
        };
        double targetValue;
        Brent brent;
        try {
            DLOG("ParStressConverter: Try to imply zero rate" << rfKey << " with bounds << " << lowerBound(rfKey) << ","
                                                              << upperBound(rfKey));
            targetValue =
                brent.solve(targetFunction, accuracy_, baseScenarioValues[rfKey], lowerBound(rfKey), upperBound(rfKey));
        } catch (const std::exception& e) {
            ALOG("ParStressConverter: Couldn't find a solution to imply a zero rate for parRate " << rfKey << ", got "
                                                                                                  << e.what());
            targetValue = simMarket_->baseScenario()->get(rfKey);
        }
        zeroSimMarketScenario->add(rfKey, targetValue);
        shifts[rfKey] = shiftsSizeForScenario(rfKey, targetValue, baseScenarioValues[rfKey]);
        updateTargetStressTestScenarioData(zeroStressScenario, rfKey, shifts[rfKey]);
    }
    simMarket_->applyScenario(zeroSimMarketScenario);
    DLOG("ParStressConverter: Implied Scenario");
    DLOG("parInstrument;fairRate;targetFairRate;zeroBaseValue;shift");
    for (const auto& rfKey : relevantParKeys) {
        DLOG(rfKey << ";" << impliedParRate(rfKey) << ";" << targets[rfKey] << ";" << baseScenarioValues[rfKey] << ";"
                   << shifts[rfKey]);
    }
    simMarket_->reset();
    return zeroStressScenario;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scenarioCanBeConverted()

bool scenarioCanBeConverted ( const StressTestScenarioData::StressTestData & parStressScenario ) const

private

check if the scenario can be converted

Check if the scenarios defines a shift for each par rate defined in the sensitivityScenarioData;.

Definition at line 272 of file parstressscenarioconverter.cpp.

                                                                         {
    DLOG("Check if the par stresstest scenario is compatible with the parInstruments");
    bool result = true;
    if (parStressScenario.irCurveParShifts) {
        // We require that shifts between stress scenario and sensi scenario are aligned
        for (const auto& [ccy, curveShifts] : parStressScenario.discountCurveShifts) {
            DLOG("Check if pillars between stress test and sensi config are alligned for discount curve " << ccy);
            result = result && checkCurveShiftData(ccy, curveShifts, sensiScenarioData_->discountCurveShiftData());
        }
 
        for (const auto& [indexName, curveShifts] : parStressScenario.indexCurveShifts) {
            DLOG("Check if pillars between stress test and sensi config are alligned for index curve " << indexName);
            result = result && checkCurveShiftData(indexName, curveShifts, sensiScenarioData_->indexCurveShiftData());
        }
 
        for (const auto& [curveName, curveShifts] : parStressScenario.yieldCurveShifts) {
            DLOG("Check if pillars between stress test and sensi config are alligned for yield curve " << curveName);
            result = result && checkCurveShiftData(curveName, curveShifts, sensiScenarioData_->yieldCurveShiftData());
        }
    }
 
    if (parStressScenario.creditCurveParShifts) {
        for (const auto& [curveName, curveShifts] : parStressScenario.survivalProbabilityShifts) {
            DLOG("Check if pillars between stress test and sensi config are alligned for credit curve " << curveName);
            result = result && checkCurveShiftData(curveName, curveShifts, sensiScenarioData_->creditCurveShiftData());
        }
    }
 
    if (parStressScenario.irCapFloorParShifts) {
        for (const auto& [capSurfaceName, capShifts] : parStressScenario.capVolShifts) {
            DLOG("Check if pillars and strikes between stress test and sensi config are alligned for cap floor surface "
                 << capSurfaceName);
            result =
                result && checkCapFloorShiftData(capSurfaceName, capShifts, sensiScenarioData_->capFloorVolShiftData());
        }
    }
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maturityTime()

double maturityTime ( const RiskFactorKey & key ) const

private

compute the time to tenor of the risk factor key

Definition at line 420 of file parstressscenarioconverter.cpp.

                                                                                {
    boost::shared_ptr<QuantLib::TermStructure> ts;
    QuantLib::Period tenor;
    switch (rfKey.keytype) {
    case RiskFactorKey::KeyType::DiscountCurve:
        ts = *simMarket_->discountCurve(rfKey.name);
        tenor = getYieldCurvePeriod(rfKey, simMarketParams_);
        break;
    case RiskFactorKey::KeyType::YieldCurve:
        ts = *simMarket_->yieldCurve(rfKey.name);
        tenor = getYieldCurvePeriod(rfKey, simMarketParams_);
        break;
    case RiskFactorKey::KeyType::IndexCurve:
        ts = *simMarket_->iborIndex(rfKey.name)->forwardingTermStructure();
        tenor = getYieldCurvePeriod(rfKey, simMarketParams_);
        break;
    case RiskFactorKey::KeyType::SurvivalProbability:
        ts = *simMarket_->defaultCurve(rfKey.name)->curve();
        QL_REQUIRE(rfKey.index < simMarketParams_->defaultTenors(rfKey.name).size(),
                   "Please align pillars, internal error");
        tenor = simMarketParams_->defaultTenors(rfKey.name)[rfKey.index];
        break;
    case RiskFactorKey::KeyType::OptionletVolatility: {
        ts = *simMarket_->capFloorVol(rfKey.name);
        auto [tenorId, strikeId] = getCapFloorTenorAndStrikeIds(rfKey);
        QL_REQUIRE(
            simMarketParams_->capFloorVolExpiries(rfKey.name).size() > tenorId,
            "Internal Error: ParStressScenarioConversion, simmarket and par sensitivity instruments are not aligned.");
        tenor = simMarketParams_->capFloorVolExpiries(rfKey.name)[tenorId];
    }
    default:
        QL_FAIL("ParStressScenario to ZeroConversion: Unsupported riskfactor, can not compute time to maturity "
                "from curve");
    }
    return ts->dayCounter().yearFraction(asof_, asof_ + tenor);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCapFloorTenorAndStrikeIds()

std::pair< size_t, size_t > getCapFloorTenorAndStrikeIds ( const RiskFactorKey & rfKey ) const

private

get the strike and tenor from a optionlet riskfactor key

Definition at line 457 of file parstressscenarioconverter.cpp.

                                                                                                                 {
    size_t nStrikes = simMarketParams_->capFloorVolStrikes(rfKey.name).size();
    size_t n = rfKey.index;
    size_t tenorId = n / nStrikes;
    size_t strikeId = n % nStrikes;
    return {tenorId, strikeId};
}

Here is the caller graph for this function:

◆ shiftsSizeForScenario()

double shiftsSizeForScenario	(	const RiskFactorKey	rfKey,
		double	targetValue,
		double	baseValue
	)		const

private

convert the scenario value to the corresponding zero shift size for the stress test data

Definition at line 465 of file parstressscenarioconverter.cpp.

                                                                                 {
    DLOG("compute shift for" << rfKey << " targetZeroValue " << targetValue << " baseValue " << baseValue);
    double shift = 0.0;
    switch (rfKey.keytype) {
    case RiskFactorKey::KeyType::DiscountCurve:
    case RiskFactorKey::KeyType::YieldCurve:
    case RiskFactorKey::KeyType::IndexCurve:
    case RiskFactorKey::KeyType::SurvivalProbability: {
        double ttm = maturityTime(rfKey);
        DLOG("TTM " << ttm);
        if (!useSpreadedTermStructure_) {
            shift = -std::log(targetValue / baseValue) / ttm;
        } else {
            shift = -std::log(targetValue) / ttm;
        }
        DLOG("Shift = " << shift);
        break;
    }
    case RiskFactorKey::KeyType::OptionletVolatility:
        if (!useSpreadedTermStructure_) {
            shift = targetValue - baseValue;
        } else {
            shift = targetValue;
        };
        break;
    default:
        QL_FAIL("ShiftSizeForScenario: Unsupported par instruments type " << rfKey.keytype);
    }
    return shift;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateTargetStressTestScenarioData()

void updateTargetStressTestScenarioData	(	StressTestScenarioData::StressTestData &	stressScenario,
		const RiskFactorKey &	key,
		const double	zeroShift
	)		const

private

add zero shifts in the stress test data

Definition at line 519 of file parstressscenarioconverter.cpp.

                                                                                                                  {
    if (key.keytype == RiskFactorKey::KeyType::DiscountCurve) {
        if (stressScenario.discountCurveShifts.count(key.name) == 0) {
            StressTestScenarioData::CurveShiftData newData;
            newData.shiftType = ShiftType::Absolute;
            newData.shiftTenors = simMarketParams_->yieldCurveTenors(key.name);
            newData.shifts = std::vector<double>(newData.shiftTenors.size(), 0.0);
            newData.shifts[key.index] = zeroShift;
            stressScenario.discountCurveShifts.insert({key.name, newData});
        } else {
            stressScenario.discountCurveShifts.at(key.name).shifts[key.index] = zeroShift;
        }
    } else if (key.keytype == RiskFactorKey::KeyType::IndexCurve) {
        if (stressScenario.indexCurveShifts.count(key.name) == 0) {
            StressTestScenarioData::CurveShiftData newData;
            newData.shiftType = ShiftType::Absolute;
            newData.shiftTenors = simMarketParams_->yieldCurveTenors(key.name);
            newData.shifts = std::vector<double>(newData.shiftTenors.size(), 0.0);
            newData.shifts[key.index] = zeroShift;
            stressScenario.indexCurveShifts.insert({key.name, newData});
        } else {
            stressScenario.indexCurveShifts.at(key.name).shifts[key.index] = zeroShift;
        }
    } else if (key.keytype == RiskFactorKey::KeyType::SurvivalProbability) {
        if (stressScenario.survivalProbabilityShifts.count(key.name) == 0) {
            StressTestScenarioData::CurveShiftData newData;
            newData.shiftType = ShiftType::Absolute;
            newData.shiftTenors = simMarketParams_->defaultTenors(key.name);
            newData.shifts = std::vector<double>(newData.shiftTenors.size(), 0.0);
            newData.shifts[key.index] = zeroShift;
            stressScenario.survivalProbabilityShifts.insert({key.name, newData});
        } else {
            stressScenario.survivalProbabilityShifts.at(key.name).shifts[key.index] = zeroShift;
        }
    } else if (key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        if (stressScenario.capVolShifts.count(key.name) == 0) {
            StressTestScenarioData::CapFloorVolShiftData newData;
            newData.shiftType = ShiftType::Absolute;
            newData.shiftExpiries = simMarketParams_->capFloorVolExpiries(key.name);
            newData.shiftStrikes = simMarketParams_->capFloorVolStrikes(key.name);
            for (size_t i = 0; i < newData.shiftExpiries.size(); ++i) {
                newData.shifts[newData.shiftExpiries[i]] = std::vector<double>(newData.shiftStrikes.size(), 0.0);
            }
            const auto& [expiryId, strikeId] = getCapFloorTenorAndStrikeIds(key);
            newData.shifts[newData.shiftExpiries[expiryId]][strikeId] = zeroShift;
            stressScenario.capVolShifts.insert({key.name, newData});
        } else {
            StressTestScenarioData::CapFloorVolShiftData& newData = stressScenario.capVolShifts.at(key.name);
            const auto& [expiryId, strikeId] = getCapFloorTenorAndStrikeIds(key);
            newData.shifts[newData.shiftExpiries[expiryId]][strikeId] = zeroShift;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ impliedParRate()

double impliedParRate ( const RiskFactorKey & key ) const

private

Compute the implied fair rate of the par instrument.

Definition at line 497 of file parstressscenarioconverter.cpp.

                                                                                {
    if (key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return impliedVolatility(key, parInstruments_);
    } else if (supportedCurveShiftTypes.count(key.keytype) == 1) {
        auto parInstIt = parInstruments_.parHelpers_.find(key);
        QL_REQUIRE(parInstIt != parInstruments_.parHelpers_.end(),
                   "Internal error, trying to compute parRate but havent build parRateHelper");
        return impliedQuote(parInstIt->second);
    } else {
        QL_FAIL("Unsupported parRate");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getStressShift()

double getStressShift	(	const RiskFactorKey &	key,
		const StressTestScenarioData::StressTestData &	stressScenario
	)		const

private

get the par stress shift size from stress test data

Definition at line 510 of file parstressscenarioconverter.cpp.

                                                                                                                    {
    if (key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return getCapFloorStressShift(key, stressScenario, simMarketParams_);
    } else {
        return getCurveStressShift(key, stressScenario);
    }
}

Here is the caller graph for this function:

◆ lowerBound()

double lowerBound ( const RiskFactorKey key ) const

private

Definition at line 574 of file parstressscenarioconverter.cpp.

                                                                           {
    if (useSpreadedTermStructure_ && key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return minVol_ - simMarket_->baseScenarioAbsolute()->get(key);
    } else if (key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return minVol_;
    } else if (useSpreadedTermStructure_ && (key.keytype == RiskFactorKey::KeyType::DiscountCurve ||
                                             key.keytype == RiskFactorKey::KeyType::YieldCurve ||
                                             key.keytype == RiskFactorKey::KeyType::IndexCurve ||
                                             key.keytype == RiskFactorKey::KeyType::SurvivalProbability)) {
        return minDiscountFactor_ / simMarket_->baseScenarioAbsolute()->get(key);
    } else {
        return minDiscountFactor_;
    }
}

Here is the caller graph for this function:

◆ upperBound()

double upperBound ( const RiskFactorKey key ) const

private

Definition at line 589 of file parstressscenarioconverter.cpp.

                                                                           {
    if (useSpreadedTermStructure_ && key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return maxVol_ * simMarket_->baseScenarioAbsolute()->get(key);
    } else if (key.keytype == RiskFactorKey::KeyType::OptionletVolatility) {
        return maxVol_ * simMarket_->baseScenarioAbsolute()->get(key);
    } else if (useSpreadedTermStructure_ && (key.keytype == RiskFactorKey::KeyType::DiscountCurve ||
                                             key.keytype == RiskFactorKey::KeyType::YieldCurve ||
                                             key.keytype == RiskFactorKey::KeyType::IndexCurve ||
                                             key.keytype == RiskFactorKey::KeyType::SurvivalProbability)) {
        return maxDiscountFactor_ / simMarket_->baseScenarioAbsolute()->get(key);
    } else {
        return maxDiscountFactor_;
    }
}