#include <orea/scenario/stressscenariogenerator.hpp>

Inheritance diagram for StressScenarioGenerator:

Collaboration diagram for StressScenarioGenerator:

Public Member Functions
	StressScenarioGenerator (const QuantLib::ext::shared_ptr< StressTestScenarioData > &stressData, const QuantLib::ext::shared_ptr< Scenario > &baseScenario, const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &simMarketData, const QuantLib::ext::shared_ptr< ScenarioSimMarket > &simMarket, const QuantLib::ext::shared_ptr< ScenarioFactory > &stressScenarioFactory, const QuantLib::ext::shared_ptr< Scenario > &baseScenarioAbsolute=nullptr)
	Constructor. More...

	~StressScenarioGenerator ()
	Default destructor. More...

Public Member Functions inherited from ShiftScenarioGenerator
	ShiftScenarioGenerator (const QuantLib::ext::shared_ptr< Scenario > &baseScenario, const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &simMarketData, const QuantLib::ext::weak_ptr< ScenarioSimMarket > &simMarket)
	Constructor. More...

	~ShiftScenarioGenerator ()
	Default destructor. More...

QuantLib::ext::shared_ptr< Scenario >	next (const Date &d) override
	Scenario Generator interface. More...

void	reset () override
	Reset the generator so calls to next() return the first scenario. More...

Size	samples ()
	Inspectors. More...

const QuantLib::ext::shared_ptr< Scenario > &	baseScenario ()
	Return the base scenario, i.e. cached initial values of all relevant market points. More...

const std::vector< QuantLib::ext::shared_ptr< Scenario > > &	scenarios ()
	Return vector of sensitivity scenarios, scenario 0 is the base scenario. More...

std::vector< ScenarioDescription >	scenarioDescriptions ()
	Return vector of scenario descriptions. More...

const std::map< RiskFactorKey, std::string > &	keyToFactor ()

const std::map< std::string, RiskFactorKey > &	factorToKey ()
	Return revers map of factors to RiskFactorKeys. More...

void	applyShift (Size j, Real shiftSize, bool up, ShiftType type, const vector< Time > &shiftTimes, const vector< Real > &values, const vector< Time > &times, vector< Real > &shiftedValues, bool initialise)
	Apply 1d triangular shift to 1d data such as yield curves, public to allow test suite access. More...

void	applyShift (Size j, Size k, Real shiftSize, bool up, ShiftType type, const vector< Time > &shiftX, const vector< Time > &shiftY, const vector< Time > &dataX, const vector< Time > &dataY, const vector< vector< Real > > &data, vector< vector< Real > > &shiftedData, bool initialise)
	Apply 2d shift to 2d matrix such as swaption volatilities, public to allow test suite access. More...

QuantLib::ext::shared_ptr< Scenario >	baseScenario () const
	return the base scenario More...

Public Member Functions inherited from ScenarioGenerator
virtual	~ScenarioGenerator ()
	Default destructor. More...

virtual QuantLib::ext::shared_ptr< Scenario >	next (const Date &d)=0
	Return the next scenario for the given date. More...

virtual void	reset ()=0
	Reset the generator so calls to next() return the first scenario. More...

Private Member Functions
void	generateScenarios ()

void	addFxShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addEquityShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addDiscountCurveShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addIndexCurveShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addYieldCurveShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addFxVolShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addEquityVolShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addSwaptionVolShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addCapFloorVolShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addSecuritySpreadShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addDefaultCurveShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addRecoveryRateShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

void	addSurvivalProbabilityShifts (StressTestScenarioData::StressTestData &data, QuantLib::ext::shared_ptr< Scenario > &scenario)

Private Attributes
QuantLib::ext::shared_ptr< StressTestScenarioData >	stressData_

QuantLib::ext::shared_ptr< ScenarioFactory >	stressScenarioFactory_

QuantLib::ext::shared_ptr< Scenario >	baseScenarioAbsolute_

Additional Inherited Members
Protected Attributes inherited from ShiftScenarioGenerator
const QuantLib::ext::shared_ptr< Scenario >	baseScenario_

const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters >	simMarketData_

const QuantLib::ext::weak_ptr< ScenarioSimMarket >	simMarket_

std::vector< QuantLib::ext::shared_ptr< Scenario > >	scenarios_

Size	counter_

std::vector< ScenarioDescription >	scenarioDescriptions_

std::map< RiskFactorKey, std::string >	keyToFactor_

std::map< std::string, RiskFactorKey >	factorToKey_

Detailed Description

Stress Scenario Generator.

This class builds a vector of stress scenarios based on instructions in StressScenarioData and ScenarioSimMarketParameters objects passed.

The ScenarioSimMarketParameters object determines the scope and structure of a "simulation" market (currencies, currency pairs, curve tenor points, vol matrix expiries and terms/strikes etc) to which sensitivity scenarios are applied in order to compute their NPV impact.

The StressScenarioData object determines the structure of shift curves (shift tenor points can differ from the simulation market's tenor points), as well as type (relative/absolute) and size of shifts applied.

The generator then produces comprehensive scenarios that can be applied to the simulation market, i.e. covering all quotes in the simulation market, possibly filled with "base" scenario values.

The generator currently covers the IR/FX asset class, with shifts for the following term structure types:

FX spot rates
FX ATM volatilities
Discount curve zero rates
Index curve zero rates
Yield curve zero rates
Swaption ATM volatility matrices
Cap/Floor volatility matrices (by expiry and strike)

Note:

For yield curves, the class applies shifts in the Zero rate domain only.
Likewise, Cap/Floor volatility stress tests are applied in the optionlet domain.

Definition at line 69 of file stressscenariogenerator.hpp.

Constructor & Destructor Documentation

◆ StressScenarioGenerator()

StressScenarioGenerator	(	const QuantLib::ext::shared_ptr< StressTestScenarioData > &	stressData,
		const QuantLib::ext::shared_ptr< Scenario > &	baseScenario,
		const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &	simMarketData,
		const QuantLib::ext::shared_ptr< ScenarioSimMarket > &	simMarket,
		const QuantLib::ext::shared_ptr< ScenarioFactory > &	stressScenarioFactory,
		const QuantLib::ext::shared_ptr< Scenario > &	baseScenarioAbsolute = `nullptr`
	)

Constructor.

Definition at line 30 of file stressscenariogenerator.cpp.

    : ShiftScenarioGenerator(baseScenario, simMarketData, simMarket), stressData_(stressData),
      stressScenarioFactory_(stressScenarioFactory),
      baseScenarioAbsolute_(baseScenarioAbsolute == nullptr ? baseScenario : baseScenarioAbsolute) {
 
    QL_REQUIRE(stressData_, "StressScenarioGenerator: stressData is null");
 
    generateScenarios();
}

Here is the call graph for this function:

◆ ~StressScenarioGenerator()

~StressScenarioGenerator ( )

Default destructor.

Definition at line 79 of file stressscenariogenerator.hpp.

79{}

Member Function Documentation

◆ generateScenarios()

void generateScenarios ( )

private

Definition at line 45 of file stressscenariogenerator.cpp.

                                                {
    Date asof = baseScenario_->asof();
    for (Size i = 0; i < stressData_->data().size(); ++i) {
        StressTestScenarioData::StressTestData data = stressData_->data().at(i);
        DLOG("Generate stress scenario #" << i << " '" << data.label << "'");
        QuantLib::ext::shared_ptr<Scenario> scenario =
            stressScenarioFactory_->buildScenario(asof, !stressData_->useSpreadedTermStructures(), data.label);
 
        if (simMarketData_->simulateFxSpots())
            addFxShifts(data, scenario);
        addEquityShifts(data, scenario);
        addDiscountCurveShifts(data, scenario);
        addIndexCurveShifts(data, scenario);
        addYieldCurveShifts(data, scenario);
        if (simMarketData_->simulateFXVols())
            addFxVolShifts(data, scenario);
        if (simMarketData_->simulateEquityVols())
            addEquityVolShifts(data, scenario);
        if (simMarketData_->simulateSwapVols())
            addSwaptionVolShifts(data, scenario);
        if (simMarketData_->simulateCapFloorVols())
            addCapFloorVolShifts(data, scenario);
        if (simMarketData_->securitySpreadsSimulate())
            addSecuritySpreadShifts(data, scenario);
        if (simMarketData_->simulateRecoveryRates())
            addRecoveryRateShifts(data, scenario);
        if (simMarketData_->simulateSurvivalProbabilities())
            addSurvivalProbabilityShifts(data, scenario);
 
        scenarios_.push_back(scenario);
    }
 
    DLOG("stress scenario generator: all scenarios generated.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addFxShifts()

void addFxShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 80 of file stressscenariogenerator.cpp.

                                                                                     {
    for (auto d : std.fxShifts) {
        string ccypair = d.first; // foreign + domestic;
 
        // Is this too strict?
        // - implemented to avoid cases where input cross FX rates are not consistent
        // - Consider an example (baseCcy = EUR) of a GBPUSD FX trade - two separate routes to pricing
        // - (a) call GBPUSD FX rate from sim market
        // - (b) call GBPEUR and EURUSD FX rates, manually join them to obtain GBPUSD
        // - now, if GBPUSD is an explicit risk factor in sim market, consider what happens
        // - if we bump GBPUSD value and leave other FX rates unchanged (for e.g. a sensitivity analysis)
        // - (a) the value of the trade changes
        // - (b) the value of the GBPUSD trade stays the same
        // in light of the above we restrict the universe of FX pairs that we support here for the time being
        string baseCcy = simMarketData_->baseCcy();
        string foreign = ccypair.substr(0, 3);
        string domestic = ccypair.substr(3);
        QL_REQUIRE((domestic == baseCcy) || (foreign == baseCcy),
                   "SensitivityScenarioGenerator does not support cross FX pairs("
                       << ccypair << ", but base currency is " << baseCcy << ")");
 
        TLOG("Apply stress scenario to fx " << ccypair);
 
        StressTestScenarioData::SpotShiftData data = d.second;
        ShiftType type = data.shiftType;
        bool relShift = (type == ShiftType::Relative);
        // QL_REQUIRE(type == ShiftType::Relative, "FX scenario type must be relative");
        Real size = data.shiftSize;
 
        RiskFactorKey key(RiskFactorKey::KeyType::FXSpot, ccypair);
        Real rate = scenario->get(key);
        Real newRate = relShift ? rate * (1.0 + size) : (rate + size);
        scenario->add(RiskFactorKey(RiskFactorKey::KeyType::FXSpot, ccypair),
                      stressData_->useSpreadedTermStructures() ? newRate / rate : newRate);
    }
    DLOG("FX scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addEquityShifts()

void addEquityShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 119 of file stressscenariogenerator.cpp.

                                                                                         {
    for (auto d : std.equityShifts) {
        string equity = d.first;
        StressTestScenarioData::SpotShiftData data = d.second;
        ShiftType type = data.shiftType;
        bool relShift = (type == ShiftType::Relative);
        // QL_REQUIRE(type == ShiftType::Relative, "FX scenario type must be relative");
        Real size = data.shiftSize;
 
        RiskFactorKey key(RiskFactorKey::KeyType::EquitySpot, equity);
        Real rate = baseScenarioAbsolute_->get(key);
 
        Real newRate = relShift ? rate * (1.0 + size) : (rate + size);
        scenario->add(RiskFactorKey(RiskFactorKey::KeyType::EquitySpot, equity),
                      stressData_->useSpreadedTermStructures() ? newRate / rate : newRate);
    }
    DLOG("Equity scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addDiscountCurveShifts()

void addDiscountCurveShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 139 of file stressscenariogenerator.cpp.

                                                                                                {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.discountCurveShifts) {
        string ccy = d.first;
        TLOG("Apply stress scenario to discount curve " << ccy);
 
        Size n_ten = simMarketData_->yieldCurveTenors(ccy).size();
        // original curves' buffer
        std::vector<Real> zeros(n_ten);
        std::vector<Real> times(n_ten);
        // buffer for shifted zero curves
        std::vector<Real> shiftedZeros(n_ten);
 
        StressTestScenarioData::CurveShiftData data = d.second;
        ShiftType shiftType = data.shiftType;
        //DayCounter dc = parseDayCounter(simMarketData_->yieldCurveDayCounter(ccy));
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->discountCurve(ccy)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        for (Size j = 0; j < n_ten; ++j) {
            Date d = asof + simMarketData_->yieldCurveTenors(ccy)[j];
            times[j] = dc.yearFraction(asof, d);
            RiskFactorKey key(RiskFactorKey::KeyType::DiscountCurve, ccy, j);
            Real quote = baseScenarioAbsolute_->get(key);
            zeros[j] = -std::log(quote) / times[j];
        }
 
        std::vector<Period> shiftTenors = data.shiftTenors;
        QL_REQUIRE(shiftTenors.size() > 0, "Discount shift tenors not specified");
        std::vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
        std::vector<Time> shiftTimes(shiftTenors.size());
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        // apply zero rate shift at tenor point j
        for (Size j = 0; j < shiftTenors.size(); ++j)
            applyShift(j, shifts[j], true, shiftType, shiftTimes, zeros, times, shiftedZeros, j == 0 ? true : false);
 
        // store shifted discount curve in the scenario
        for (Size k = 0; k < n_ten; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::DiscountCurve, ccy, k);
            Real shiftedDiscount = exp(-shiftedZeros[k] * times[k]);
            if (stressData_->useSpreadedTermStructures()) {
                Real discount = exp(-zeros[k] * times[k]);
                scenario->add(key, shiftedDiscount / discount);
            } else {
                scenario->add(key, shiftedDiscount);
            }
        }
    }
    DLOG("Discount curve stress scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addIndexCurveShifts()

void addIndexCurveShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 259 of file stressscenariogenerator.cpp.

                                                                                             {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.indexCurveShifts) {
        string indexName = d.first;
        TLOG("Apply stress scenario to index curve " << indexName);
 
        Size n_ten = simMarketData_->yieldCurveTenors(indexName).size();
 
        // original curves' buffer
        std::vector<Real> zeros(n_ten);
        std::vector<Real> times(n_ten);
 
        // buffer for shifted zero curves
        std::vector<Real> shiftedZeros(n_ten);
 
        StressTestScenarioData::CurveShiftData data = d.second;
        ShiftType shiftType = data.shiftType;
        //DayCounter dc = parseDayCounter(simMarketData_->yieldCurveDayCounter(indexName));
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->iborIndex(indexName)->forwardingTermStructure()->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        for (Size j = 0; j < n_ten; ++j) {
            Date d = asof + simMarketData_->yieldCurveTenors(indexName)[j];
            times[j] = dc.yearFraction(asof, d);
            RiskFactorKey key(RiskFactorKey::KeyType::IndexCurve, indexName, j);
            Real quote = baseScenarioAbsolute_->get(key);
            zeros[j] = -std::log(quote) / times[j];
        }
 
        std::vector<Period> shiftTenors = data.shiftTenors;
        QL_REQUIRE(shiftTenors.size() > 0, "Index curve shift tenors not specified");
        std::vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
        std::vector<Time> shiftTimes(shiftTenors.size());
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        for (Size j = 0; j < shiftTenors.size(); ++j)
            applyShift(j, shifts[j], true, shiftType, shiftTimes, zeros, times, shiftedZeros, j == 0 ? true : false);
 
        // store shifted discount curve for this index in the scenario
        for (Size k = 0; k < n_ten; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::IndexCurve, indexName, k);
            Real shiftedDiscount = exp(-shiftedZeros[k] * times[k]);
            if (stressData_->useSpreadedTermStructures()) {
                Real discount = exp(-zeros[k] * times[k]);
                scenario->add(key, shiftedDiscount / discount);
            } else {
                scenario->add(key, shiftedDiscount);
            }
        }
    }
    DLOG("Index curve scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addYieldCurveShifts()

void addYieldCurveShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 320 of file stressscenariogenerator.cpp.

                                                                                             {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.yieldCurveShifts) {
        string name = d.first;
        TLOG("Apply stress scenario to yield curve " << name);
 
        Size n_ten = simMarketData_->yieldCurveTenors(name).size();
 
        // original curves' buffer
        std::vector<Real> zeros(n_ten);
        std::vector<Real> times(n_ten);
 
        // buffer for shifted zero curves
        std::vector<Real> shiftedZeros(n_ten);
 
        StressTestScenarioData::CurveShiftData data = d.second;
        ShiftType shiftType = data.shiftType;
        //DayCounter dc = parseDayCounter(simMarketData_->yieldCurveDayCounter(name));
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->yieldCurve(name)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        for (Size j = 0; j < n_ten; ++j) {
            Date d = asof + simMarketData_->yieldCurveTenors(name)[j];
            times[j] = dc.yearFraction(asof, d);
            RiskFactorKey key(RiskFactorKey::KeyType::YieldCurve, name, j);
            Real quote = baseScenarioAbsolute_->get(key);
            zeros[j] = -std::log(quote) / times[j];
        }
 
        std::vector<Period> shiftTenors = data.shiftTenors;
        QL_REQUIRE(shiftTenors.size() > 0, "Yield curve shift tenors not specified");
        std::vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
        std::vector<Time> shiftTimes(shiftTenors.size());
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        for (Size j = 0; j < shiftTenors.size(); ++j) {
            // DLOG("apply yield curve shift " << shifts[j] << " to curve " << name << " at tenor " << shiftTenors[j]
            //                                 << ", time " << shiftTimes[j]);
            // apply zero rate shift at tenor point j
            applyShift(j, shifts[j], true, shiftType, shiftTimes, zeros, times, shiftedZeros, j == 0 ? true : false);
        }
 
        // store shifted discount curve in the scenario
        for (Size k = 0; k < n_ten; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::YieldCurve, name, k);
            Real shiftedDiscount = exp(-shiftedZeros[k] * times[k]);
            if (stressData_->useSpreadedTermStructures()) {
                Real discount = exp(-zeros[k] * times[k]);
                scenario->add(key, shiftedDiscount / discount);
            } else {
                scenario->add(key, shiftedDiscount);
            }
        }
    } // end of shift curve tenors
    DLOG("Yield curve scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addFxVolShifts()

void addFxVolShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 385 of file stressscenariogenerator.cpp.

                                                                                        {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.fxVolShifts) {
        string ccypair = d.first;
        TLOG("Apply stress scenario to fx vol structure " << ccypair);
 
        Size n_fxvol_exp = simMarketData_->fxVolExpiries(ccypair).size();
 
        std::vector<Real> values(n_fxvol_exp);
        std::vector<Real> times(n_fxvol_exp);
 
        // buffer for shifted zero curves
        std::vector<Real> shiftedValues(n_fxvol_exp);
 
        StressTestScenarioData::VolShiftData data = d.second;
 
        //DayCounter dc = parseDayCounter(simMarketData_->fxVolDayCounter(ccypair));
        DayCounter dc;
        if (auto s = simMarket_.lock()) {
            dc = s->fxVol(ccypair)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
        for (Size j = 0; j < n_fxvol_exp; ++j) {
            Date d = asof + simMarketData_->fxVolExpiries(ccypair)[j];
 
            RiskFactorKey key(RiskFactorKey::KeyType::FXVolatility, ccypair, j);
            values[j] = baseScenarioAbsolute_->get(key);
 
            times[j] = dc.yearFraction(asof, d);
        }
 
        ShiftType shiftType = data.shiftType;
        std::vector<Period> shiftTenors = data.shiftExpiries;
        std::vector<Time> shiftTimes(shiftTenors.size());
        vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() > 0, "FX vol shift tenors not specified");
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
 
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        // FIXME: Apply same shifts to non-ATM vectors if present
        for (Size j = 0; j < shiftTenors.size(); ++j) {
            // apply shift at tenor point j
            applyShift(j, shifts[j], true, shiftType, shiftTimes, values, times, shiftedValues, j == 0 ? true : false);
        }
 
        for (Size k = 0; k < n_fxvol_exp; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::FXVolatility, ccypair, k);
            if (stressData_->useSpreadedTermStructures()) {
                scenario->add(key, shiftedValues[k] - values[k]);
            } else {
                scenario->add(key, shiftedValues[k]);
            }
        }
    }
    DLOG("FX vol scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addEquityVolShifts()

void addEquityVolShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 447 of file stressscenariogenerator.cpp.

                                                                                            {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.equityVolShifts) {
        string equity = d.first;
        TLOG("Apply stress scenario to equity vol structure " << equity);
        Size n_eqvol_exp = simMarketData_->equityVolExpiries(equity).size();
 
        std::vector<Real> values(n_eqvol_exp);
        std::vector<Real> times(n_eqvol_exp);
 
        // buffer for shifted zero curves
        std::vector<Real> shiftedValues(n_eqvol_exp);
 
        StressTestScenarioData::VolShiftData data = d.second;
 
        //DayCounter dc = parseDayCounter(simMarketData_->equityVolDayCounter(equity));
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->equityVol(equity)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
        for (Size j = 0; j < n_eqvol_exp; ++j) {
            Date d = asof + simMarketData_->equityVolExpiries(equity)[j];
 
            RiskFactorKey key(RiskFactorKey::KeyType::EquityVolatility, equity, j);
            values[j] = baseScenarioAbsolute_->get(key);
 
            times[j] = dc.yearFraction(asof, d);
        }
 
        ShiftType shiftType = data.shiftType;
        std::vector<Period> shiftTenors = data.shiftExpiries;
        std::vector<Time> shiftTimes(shiftTenors.size());
        vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() > 0, "Equity vol shift tenors not specified");
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
 
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        // FIXME: Apply same shifts to non-ATM vectors if present
        for (Size j = 0; j < shiftTenors.size(); ++j) {
            // apply shift at tenor point j
            applyShift(j, shifts[j], true, shiftType, shiftTimes, values, times, shiftedValues, j == 0 ? true : false);
        }
 
        for (Size k = 0; k < n_eqvol_exp; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::EquityVolatility, equity, k);
            if (stressData_->useSpreadedTermStructures()) {
                scenario->add(key, shiftedValues[k] - values[k]);
            } else {
                scenario->add(key, shiftedValues[k]);
            }
        }
    }
    DLOG("Equity vol scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addSwaptionVolShifts()

void addSwaptionVolShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 508 of file stressscenariogenerator.cpp.

                                                                                              {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.swaptionVolShifts) {
        std::string key = d.first;
        TLOG("Apply stress scenario to swaption vol structure '" << key << "'");
 
        Size n_swvol_term = simMarketData_->swapVolTerms(key).size();
        Size n_swvol_exp = simMarketData_->swapVolExpiries(key).size();
 
        vector<vector<Real>> volData(n_swvol_exp, vector<Real>(n_swvol_term, 0.0));
        vector<Real> volExpiryTimes(n_swvol_exp, 0.0);
        vector<Real> volTermTimes(n_swvol_term, 0.0);
        vector<vector<Real>> shiftedVolData(n_swvol_exp, vector<Real>(n_swvol_term, 0.0));
 
        StressTestScenarioData::SwaptionVolShiftData data = d.second;
        ShiftType shiftType = data.shiftType;
        map<pair<Period, Period>, Real> shifts = data.shifts;
 
        vector<Real> shiftExpiryTimes(data.shiftExpiries.size(), 0.0);
        vector<Real> shiftTermTimes(data.shiftTerms.size(), 0.0);
 
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->swaptionVol(key)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        // cache original vol data
        for (Size j = 0; j < n_swvol_exp; ++j) {
            Date expiry = asof + simMarketData_->swapVolExpiries(key)[j];
            volExpiryTimes[j] = dc.yearFraction(asof, expiry);
        }
        for (Size j = 0; j < n_swvol_term; ++j) {
            Date term = asof + simMarketData_->swapVolTerms(key)[j];
            volTermTimes[j] = dc.yearFraction(asof, term);
        }
        for (Size j = 0; j < n_swvol_exp; ++j) {
            for (Size k = 0; k < n_swvol_term; ++k) {
                Size idx = j * n_swvol_term + k;
 
                RiskFactorKey rf(RiskFactorKey::KeyType::SwaptionVolatility, key, idx);
                volData[j][k] = baseScenarioAbsolute_->get(rf);
            }
        }
 
        // cache tenor times
        for (Size j = 0; j < shiftExpiryTimes.size(); ++j)
            shiftExpiryTimes[j] = dc.yearFraction(asof, asof + data.shiftExpiries[j]);
        for (Size j = 0; j < shiftTermTimes.size(); ++j)
            shiftTermTimes[j] = dc.yearFraction(asof, asof + data.shiftTerms[j]);
 
        // loop over shift expiries and terms
        // FIXME: apply same shifts to all strikes when present
        for (Size j = 0; j < shiftExpiryTimes.size(); ++j) {
            for (Size k = 0; k < shiftTermTimes.size(); ++k) {
                // Size strikeBucket = 0; // FIXME
                Real shift = 0.0;
                pair<Period, Period> key(data.shiftExpiries[j], data.shiftTerms[k]);
                if (shifts.size() == 0)
                    shift = data.parallelShiftSize;
                else {
                    QL_REQUIRE(shifts.find(key) != shifts.end(), "swaption vol shift not found for expiry "
                                                                     << data.shiftExpiries[j] << " and term "
                                                                     << data.shiftTerms[k]);
                    shift = shifts[key];
                }
                applyShift(j, k, shift, true, shiftType, shiftExpiryTimes, shiftTermTimes, volExpiryTimes, volTermTimes,
                           volData, shiftedVolData, j == 0 && k == 0);
            }
        }
 
        // add shifted vol data to the scenario
        for (Size jj = 0; jj < n_swvol_exp; ++jj) {
            for (Size kk = 0; kk < n_swvol_term; ++kk) {
                Size idx = jj * n_swvol_term + kk;
                RiskFactorKey rfkey(RiskFactorKey::KeyType::SwaptionVolatility, key, idx);
                if (stressData_->useSpreadedTermStructures()) {
                    scenario->add(rfkey, shiftedVolData[jj][kk] - volData[jj][kk]);
                } else {
                    scenario->add(rfkey, shiftedVolData[jj][kk]);
                }
            }
        }
    }
    DLOG("Swaption vol scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addCapFloorVolShifts()

void addCapFloorVolShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 598 of file stressscenariogenerator.cpp.

                                                                                              {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.capVolShifts) {
        std::string key = d.first;
        TLOG("Apply stress scenario to cap/floor vol structure " << key);
 
        vector<Real> volStrikes = simMarketData_->capFloorVolStrikes(key);
        // Strikes may be empty which indicates that the optionlet structure in the simulation market is an ATM curve
        if (volStrikes.empty()) {
            volStrikes = {0.0};
        }
        Size n_cfvol_strikes = volStrikes.size();
 
        Size n_cfvol_exp = simMarketData_->capFloorVolExpiries(key).size();
        vector<vector<Real>> volData(n_cfvol_exp, vector<Real>(n_cfvol_strikes, 0.0));
        vector<Real> volExpiryTimes(n_cfvol_exp, 0.0);
        vector<vector<Real>> shiftedVolData(n_cfvol_exp, vector<Real>(n_cfvol_strikes, 0.0));
 
        StressTestScenarioData::CapFloorVolShiftData data = d.second;
 
        ShiftType shiftType = data.shiftType;
        
        vector<Real> shiftExpiryTimes(data.shiftExpiries.size(), 0.0);
        vector<Real> shiftStrikes = data.shiftStrikes.empty() ? volStrikes : data.shiftStrikes;
        
        vector<vector<Real>> shifts;
        for (size_t i = 0; i < data.shiftExpiries.size(); ++i) {
            const auto tenor = data.shiftExpiries[i];
            if (data.shiftStrikes.empty()){
                const double shift = data.shifts[tenor].front();
                shifts.push_back(std::vector<Real>(volStrikes.size(), shift));
            } else{
                shifts.push_back(data.shifts[tenor]);
            }
        }
 
        // DayCounter dc = parseDayCounter(simMarketData_->capFloorVolDayCounter(key));
        DayCounter dc;
        if (auto s = simMarket_.lock()) {
            dc = s->capFloorVol(key)->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        // cache original vol data
        for (Size j = 0; j < n_cfvol_exp; ++j) {
            Date expiry = asof + simMarketData_->capFloorVolExpiries(key)[j];
            volExpiryTimes[j] = dc.yearFraction(asof, expiry);
        }
        for (Size j = 0; j < n_cfvol_exp; ++j) {
            for (Size k = 0; k < n_cfvol_strikes; ++k) {
                Size idx = j * n_cfvol_strikes + k;
                volData[j][k] =
                    baseScenarioAbsolute_->get(RiskFactorKey(RiskFactorKey::KeyType::OptionletVolatility, key, idx));
            }
        }
 
        // cache tenor times
        for (Size j = 0; j < shiftExpiryTimes.size(); ++j)
            shiftExpiryTimes[j] = dc.yearFraction(asof, asof + data.shiftExpiries[j]);
 
        // loop over shift expiries, apply same shifts across all strikes
        
        for (Size j = 0; j < shiftExpiryTimes.size(); ++j) {
            for (Size k = 0; k < shiftStrikes.size(); ++k) {
                applyShift(j, k, shifts[j][k], true, shiftType, shiftExpiryTimes, shiftStrikes, volExpiryTimes, volStrikes,
                           volData, shiftedVolData, j == 0 && k == 0);
            }
        }
 
        // add shifted vol data to the scenario
        for (Size jj = 0; jj < n_cfvol_exp; ++jj) {
            for (Size kk = 0; kk < n_cfvol_strikes; ++kk) {
                Size idx = jj * n_cfvol_strikes + kk;
                RiskFactorKey rfkey(RiskFactorKey::KeyType::OptionletVolatility, key, idx);
                if (stressData_->useSpreadedTermStructures()) {
                    scenario->add(rfkey, shiftedVolData[jj][kk] - volData[jj][kk]);
                } else {
                    scenario->add(rfkey, shiftedVolData[jj][kk]);
                }
            }
        }
    }
    DLOG("Optionlet vol scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addSecuritySpreadShifts()

void addSecuritySpreadShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 686 of file stressscenariogenerator.cpp.

                                                                                                 {
    for (auto d : std.securitySpreadShifts) {
        string bond = d.first;
        TLOG("Apply stress scenario to security spread " << bond);
        StressTestScenarioData::SpotShiftData data = d.second;
        ShiftType type = data.shiftType;
        bool relShift = (type == ShiftType::Relative);
        Real size = data.shiftSize;
 
        RiskFactorKey key(RiskFactorKey::KeyType::SecuritySpread, bond);
        Real base_spread = baseScenarioAbsolute_->get(key);
 
        Real newSpread = relShift ? base_spread * (1.0 + size) : (base_spread + size);
        scenario->add(RiskFactorKey(RiskFactorKey::KeyType::SecuritySpread, bond),
                      stressData_->useSpreadedTermStructures() ? newSpread - base_spread : newSpread);
    }
    DLOG("Security spread scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addDefaultCurveShifts()

void addDefaultCurveShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

◆ addRecoveryRateShifts()

void addRecoveryRateShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 706 of file stressscenariogenerator.cpp.

                                                                                               {
    for (auto d : std.recoveryRateShifts) {
        string isin = d.first;
        TLOG("Apply stress scenario to recovery rate " << isin);
        StressTestScenarioData::SpotShiftData data = d.second;
        ShiftType type = data.shiftType;
        bool relShift = (type == ShiftType::Relative);
        Real size = data.shiftSize;
 
        RiskFactorKey key(RiskFactorKey::KeyType::RecoveryRate, isin);
        Real base_recoveryRate = baseScenarioAbsolute_->get(key);
        Real new_recoveryRate = relShift ? base_recoveryRate * (1.0 + size) : (base_recoveryRate + size);
        scenario->add(RiskFactorKey(RiskFactorKey::KeyType::RecoveryRate, isin),
                      stressData_->useSpreadedTermStructures() ? new_recoveryRate - base_recoveryRate
                                                               : new_recoveryRate);
    }
    DLOG("Recovery rate scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addSurvivalProbabilityShifts()

void addSurvivalProbabilityShifts	(	StressTestScenarioData::StressTestData &	data,
		QuantLib::ext::shared_ptr< Scenario > &	scenario
	)

private

Definition at line 199 of file stressscenariogenerator.cpp.

                                                                                                      {
    Date asof = baseScenario_->asof();
 
    for (auto d : std.survivalProbabilityShifts) {
        string name = d.first;
        TLOG("Apply stress scenario to " << name);
 
        Size n_ten = simMarketData_->defaultTenors(name).size();
        // original curves' buffer
        std::vector<Real> zeros(n_ten);
        std::vector<Real> times(n_ten);
        // buffer for shifted zero curves
        std::vector<Real> shiftedZeros(n_ten);
 
        StressTestScenarioData::CurveShiftData data = d.second;
        ShiftType shiftType = data.shiftType;
        //DayCounter dc = parseDayCounter(simMarketData_->defaultCurveDayCounter(name));
    DayCounter dc;
        if(auto s = simMarket_.lock()) {
            dc = s->defaultCurve(name)->curve()->dayCounter();
        } else {
            QL_FAIL("Internal error: could not lock simMarket. Contact dev.");
        }
 
        for (Size j = 0; j < n_ten; ++j) {
            Date d = asof + simMarketData_->defaultTenors(name)[j];
            times[j] = dc.yearFraction(asof, d);
            RiskFactorKey key(RiskFactorKey::KeyType::SurvivalProbability, name, j);
            Real quote = baseScenarioAbsolute_->get(key);
            zeros[j] = -std::log(quote) / times[j];
        }
 
        std::vector<Period> shiftTenors = data.shiftTenors;
        QL_REQUIRE(shiftTenors.size() > 0, "Survival Probability shift tenors not specified");
        std::vector<Real> shifts = data.shifts;
        QL_REQUIRE(shiftTenors.size() == shifts.size(), "shift tenor and shift size vectors do not match");
        std::vector<Time> shiftTimes(shiftTenors.size());
        for (Size j = 0; j < shiftTenors.size(); ++j)
            shiftTimes[j] = dc.yearFraction(asof, asof + shiftTenors[j]);
 
        // apply zero rate shift at tenor point j
        for (Size j = 0; j < shiftTenors.size(); ++j)
            applyShift(j, shifts[j], true, shiftType, shiftTimes, zeros, times, shiftedZeros, j == 0 ? true : false);
 
        // store shifted discount curve in the scenario
        for (Size k = 0; k < n_ten; ++k) {
            RiskFactorKey key(RiskFactorKey::KeyType::SurvivalProbability, name, k);
            Real shiftedSurvivalProbability = exp(-shiftedZeros[k] * times[k]);
            if (stressData_->useSpreadedTermStructures()) {
                Real survivalProbability = exp(-zeros[k] * times[k]);
                scenario->add(key, shiftedSurvivalProbability / survivalProbability);
            } else {
                scenario->add(key, shiftedSurvivalProbability);
            }
        }
    }
    DLOG("Default Curve stress scenarios done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ stressData_

QuantLib::ext::shared_ptr<StressTestScenarioData> stressData_

private

Definition at line 98 of file stressscenariogenerator.hpp.

◆ stressScenarioFactory_

QuantLib::ext::shared_ptr<ScenarioFactory> stressScenarioFactory_

private

Definition at line 99 of file stressscenariogenerator.hpp.

◆ baseScenarioAbsolute_

QuantLib::ext::shared_ptr<Scenario> baseScenarioAbsolute_

private

Definition at line 100 of file stressscenariogenerator.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ StressScenarioGenerator()

◆ ~StressScenarioGenerator()

Member Function Documentation

◆ generateScenarios()

◆ addFxShifts()

◆ addEquityShifts()

◆ addDiscountCurveShifts()

◆ addIndexCurveShifts()

◆ addYieldCurveShifts()

◆ addFxVolShifts()

◆ addEquityVolShifts()

◆ addSwaptionVolShifts()

◆ addCapFloorVolShifts()

◆ addSecuritySpreadShifts()

◆ addDefaultCurveShifts()

◆ addRecoveryRateShifts()

◆ addSurvivalProbabilityShifts()

Member Data Documentation

◆ stressData_

◆ stressScenarioFactory_

◆ baseScenarioAbsolute_