sensitivityvsanalytic.cpp File Reference

#include <oret/toplevelfixture.hpp>
#include <test/oreatoplevelfixture.hpp>
#include "testmarket.hpp"
#include "testportfolio.hpp"
#include <orea/scenario/deltascenariofactory.hpp>
#include <qle/pricingengines/analyticeuropeanenginedeltagamma.hpp>
#include <qle/pricingengines/blackswaptionenginedeltagamma.hpp>
#include <qle/pricingengines/discountingswapenginedeltagamma.hpp>
#include <orea/cube/inmemorycube.hpp>
#include <orea/cube/npvcube.hpp>
#include <orea/engine/filteredsensitivitystream.hpp>
#include <orea/engine/observationmode.hpp>
#include <orea/engine/parametricvar.hpp>
#include <orea/engine/riskfilter.hpp>
#include <orea/engine/sensitivityaggregator.hpp>
#include <orea/engine/sensitivityanalysis.hpp>
#include <orea/engine/sensitivitycubestream.hpp>
#include <orea/engine/sensitivityfilestream.hpp>
#include <orea/engine/sensitivityinmemorystream.hpp>
#include <orea/engine/sensitivityrecord.hpp>
#include <orea/engine/sensitivitystream.hpp>
#include <orea/engine/stresstest.hpp>
#include <orea/engine/valuationcalculator.hpp>
#include <orea/engine/valuationengine.hpp>
#include <orea/scenario/scenariosimmarket.hpp>
#include <orea/scenario/scenariosimmarketparameters.hpp>
#include <orea/scenario/sensitivityscenariodata.hpp>
#include <orea/scenario/sensitivityscenariogenerator.hpp>
#include <ored/model/lgmdata.hpp>
#include <ored/portfolio/builders/capfloor.hpp>
#include <ored/portfolio/builders/fxforward.hpp>
#include <ored/portfolio/builders/fxoption.hpp>
#include <ored/portfolio/builders/swap.hpp>
#include <ored/portfolio/builders/swaption.hpp>
#include <ored/portfolio/fxoption.hpp>
#include <ored/portfolio/portfolio.hpp>
#include <ored/portfolio/swap.hpp>
#include <ored/portfolio/swaption.hpp>
#include <ored/utilities/log.hpp>
#include <ored/utilities/osutils.hpp>
#include <ql/math/randomnumbers/mt19937uniformrng.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/date.hpp>
#include <ql/time/daycounters/actualactual.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testSensitivities)

Function Documentation

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

testSensitivities

)

Definition at line 406 of file sensitivityvsanalytic.cpp.

                                        {
 
    BOOST_TEST_MESSAGE("Checking sensitivity analysis results vs analytic sensi engine results...");
 
    SavedSettings backup;
 
    ObservationMode::Mode backupMode = ObservationMode::instance().mode();
    ObservationMode::instance().setMode(ObservationMode::Mode::None);
 
    Date today = Date(14, April, 2016); // Settings::instance().evaluationDate();
    Settings::instance().evaluationDate() = today;
 
    BOOST_TEST_MESSAGE("Today is " << today);
 
    // Init market
    QuantLib::ext::shared_ptr<Market> initMarket = QuantLib::ext::make_shared<testsuite::TestMarket>(today);
 
    // build scenario sim market parameters
    QuantLib::ext::shared_ptr<analytics::ScenarioSimMarketParameters> simMarketData = setupSimMarketData5();
 
    // sensitivity config
    QuantLib::ext::shared_ptr<SensitivityScenarioData> sensiData = setupSensitivityScenarioData5(false);
 
    // build scenario sim market
    InstrumentConventions::instance().setConventions(conv());
    QuantLib::ext::shared_ptr<analytics::ScenarioSimMarket> simMarket =
        QuantLib::ext::make_shared<analytics::ScenarioSimMarket>(initMarket, simMarketData);
 
    // build scenario factory
    QuantLib::ext::shared_ptr<Scenario> baseScenario = simMarket->baseScenario();
    QuantLib::ext::shared_ptr<ScenarioFactory> scenarioFactory = QuantLib::ext::make_shared<DeltaScenarioFactory>(baseScenario);
 
    // build scenario generator
    QuantLib::ext::shared_ptr<SensitivityScenarioGenerator> scenarioGenerator =
        QuantLib::ext::make_shared<SensitivityScenarioGenerator>(sensiData, baseScenario, simMarketData, simMarket,
                                                         scenarioFactory, false);
    simMarket->scenarioGenerator() = scenarioGenerator;
 
    // build porfolio
    QuantLib::ext::shared_ptr<EngineData> data = QuantLib::ext::make_shared<EngineData>();
    data->model("Swap") = "DiscountedCashflows";
    data->engine("Swap") = "DiscountingSwapEngine";
    data->model("CrossCurrencySwap") = "DiscountedCashflows";
    data->engine("CrossCurrencySwap") = "DiscountingCrossCurrencySwapEngine";
    data->model("FxOption") = "GarmanKohlhagen";
    data->engine("FxOption") = "AnalyticEuropeanEngine";
    QuantLib::ext::shared_ptr<EngineFactory> factory = QuantLib::ext::make_shared<EngineFactory>(data, simMarket);
 
    // QuantLib::ext::shared_ptr<Portfolio> portfolio = buildSwapPortfolio(portfolioSize, factory);
    QuantLib::ext::shared_ptr<Portfolio> portfolio(new Portfolio());
    portfolio->add(testsuite::buildSwap("1_Swap_EUR", "EUR", true, 10.0, 0, 10, 0.03, 0.00, "1Y", "30/360",
                                                "6M", "A360", "EUR-EURIBOR-6M"));
    portfolio->add(testsuite::buildFxOption("7_FxOption_EUR_USD", "Long", "Call", 3, "EUR", 10.0, "USD", 11.0));
    portfolio->build(factory);
 
    BOOST_TEST_MESSAGE("Portfolio size after build: " << portfolio->size());
 
    // analytic results
 
    std::map<string, Real> analyticalResultsDelta, analyticalResultsGamma, analyticalResultsCrossGamma;
    std::vector<Real> bucketTimes, bucketTimesVegaOpt, bucketTimesVegaUnd, bucketTimesFxOpt;
    std::vector<string> bucketStr, numStr, bucketStrVega, numStrVega, bucketStrFxVega, numStrFxVega;
    ActualActual dc(ActualActual::ISDA); // this is the dc used for the init / sim market curves
    Size i = 0;
    for (auto const& p : sensiData->discountCurveShiftData()["EUR"]->shiftTenors) {
        bucketTimes.push_back(dc.yearFraction(today, today + p));
        ostringstream bs;
        bs << p;
        bucketStr.push_back(bs.str());
        ostringstream num;
        num << i++;
        numStr.push_back(num.str());
    }
    for (auto const& p : sensiData->swaptionVolShiftData()["EUR"].shiftExpiries) {
        bucketTimesVegaOpt.push_back(dc.yearFraction(today, today + p));
    }
    for (auto const& p : sensiData->swaptionVolShiftData()["EUR"].shiftTerms) {
        bucketTimesVegaUnd.push_back(dc.yearFraction(today, today + p));
    }
    i = 0;
    for (auto const& p1 : sensiData->swaptionVolShiftData()["EUR"].shiftExpiries) {
        for (auto const& p2 : sensiData->swaptionVolShiftData()["EUR"].shiftTerms) {
            ostringstream bs, num;
            bs << p1 << "/" << p2;
            num << i++;
            bucketStrVega.push_back(bs.str());
            numStrVega.push_back(num.str());
        }
    }
    i = 0;
    for (auto const& p : sensiData->fxVolShiftData()["EURUSD"].shiftExpiries) {
        bucketTimesFxOpt.push_back(dc.yearFraction(today, today + p));
        ostringstream bs, num;
        bs << p;
        num << i++;
        bucketStrFxVega.push_back(bs.str());
        numStrFxVega.push_back(num.str());
    }
 
    Size n = bucketTimes.size();
    auto analyticSwapEngine = QuantLib::ext::make_shared<DiscountingSwapEngineDeltaGamma>(simMarket->discountCurve("EUR"),
                                                                                  bucketTimes, true, true, true, false);
    auto swap0 = portfolio->trades().begin()->second->instrument()->qlInstrument();
    swap0->setPricingEngine(analyticSwapEngine);
    auto deltaDsc0 = swap0->result<std::vector<Real>>("deltaDiscount");
    auto deltaFwd0 = swap0->result<std::vector<Real>>("deltaForward");
    auto gamma0 = swap0->result<Matrix>("gamma");
 
    auto process =
        QuantLib::ext::make_shared<GarmanKohlagenProcess>(simMarket->fxRate("EURUSD"), simMarket->discountCurve("EUR"),
                                                  simMarket->discountCurve("USD"), simMarket->fxVol("EURUSD"));
    auto analyticFxEngine =
        QuantLib::ext::make_shared<AnalyticEuropeanEngineDeltaGamma>(process, bucketTimes, bucketTimesFxOpt, true, true, false);
    auto fxoption2 = (++portfolio->trades().begin())->second->instrument()->qlInstrument();
    fxoption2->setPricingEngine(analyticFxEngine);
    Real deltaSpot2 = fxoption2->result<Real>("deltaSpot");
    Real gammaSpot2 = fxoption2->result<Real>("gammaSpot");
    auto vega2 = fxoption2->result<std::vector<Real>>("vega");
    auto deltaRate2 = fxoption2->result<std::vector<Real>>("deltaRate");
    auto deltaDividend2 = fxoption2->result<std::vector<Real>>("deltaDividend");
    auto gamma2 = fxoption2->result<Matrix>("gamma");
    Real fxnpv = fxoption2->NPV();
    Real fxspot = simMarket->fxRate("EURUSD")->value();
 
    std::vector<string> dscKey, dscKey2, fwdKey;
    for (Size i = 0; i < n; ++i) {
        dscKey.push_back("DiscountCurve/EUR/" + numStr[i] + "/" + bucketStr[i]);
        dscKey2.push_back("DiscountCurve/USD/" + numStr[i] + "/" + bucketStr[i]);
        fwdKey.push_back("IndexCurve/EUR-EURIBOR-6M/" + numStr[i] + "/" + bucketStr[i]);
    }
 
    for (Size i = 0; i < n; ++i) {
        analyticalResultsDelta["1_Swap_EUR " + dscKey[i]] = deltaDsc0[i];
        analyticalResultsDelta["1_Swap_EUR " + fwdKey[i]] = deltaFwd0[i];
        analyticalResultsDelta["7_FxOption_EUR_USD " + dscKey[i]] = deltaDividend2[i] * 10.0 / fxspot; // convert to EUR
        analyticalResultsDelta["7_FxOption_EUR_USD " + dscKey2[i]] = deltaRate2[i] * 10.0 / fxspot;    // convert to EUR
    }
 
    for (Size i = 0; i < n; ++i) {
        analyticalResultsGamma["1_Swap_EUR " + dscKey[i]] = gamma0[i][i];
        analyticalResultsGamma["1_Swap_EUR " + fwdKey[i]] = gamma0[n + i][n + i];
        analyticalResultsGamma["7_FxOption_EUR_USD " + dscKey[i]] =
            gamma2[n + i][n + i] * 10.0 / fxspot;                                                  // convert to EUR
        analyticalResultsGamma["7_FxOption_EUR_USD " + dscKey2[i]] = gamma2[i][i] * 10.0 / fxspot; // convert to EUR
        for (Size j = 0; j < n; ++j) {
            if (i < j) {
                analyticalResultsCrossGamma["1_Swap_EUR " + dscKey[i] + " " + dscKey[j]] = gamma0[i][j];
                analyticalResultsCrossGamma["1_Swap_EUR " + fwdKey[i] + " " + fwdKey[j]] = gamma0[n + i][n + j];
                analyticalResultsCrossGamma["7_FxOption_EUR_USD " + dscKey[i] + " " + dscKey[j]] =
                    gamma2[n + i][n + j] * 10.0 / fxspot; // convert to EUR
                analyticalResultsCrossGamma["7_FxOption_EUR_USD " + dscKey2[i] + " " + dscKey2[j]] =
                    gamma2[i][j] * 10.0 / fxspot; // convert to EUR
            }
            analyticalResultsCrossGamma["1_Swap_EUR " + dscKey[i] + " " + fwdKey[j]] = gamma0[i][n + j];
            analyticalResultsCrossGamma["7_FxOption_EUR_USD " + dscKey[i] + " " + dscKey2[j]] =
                gamma2[n + i][j] * 10.0 / fxspot; // convert to EUR
        }
    }
 
    // the sensitivity framework computes d/dS (npv/S), with S = EURUSD fx rate, npv = NPV in USD
    // the analytical engine computes d/dS npv, the first expression is
    // -npv/S^2+ d/dS npv / S
    // furthermore the analytical engine produces results for an EUR notional of 1 instead of 10
    analyticalResultsDelta["7_FxOption_EUR_USD FXSpot/EURUSD/0/spot"] =
        10.0 * (deltaSpot2 / fxspot - fxnpv / (fxspot * fxspot));
    // ... differentiate the above expression by S again gives
    // 2npv/S^3-2 d/dS npv / S^2 + d^2/dS^2 npv / S
    analyticalResultsGamma["7_FxOption_EUR_USD FXSpot/EURUSD/0/spot"] =
        10.0 * (2.0 * fxnpv / (fxspot * fxspot * fxspot) - 2.0 * deltaSpot2 / (fxspot * fxspot) + gammaSpot2 / fxspot);
 
    analyticalResultsDelta["7_FxOption_EUR_USD FXVolatility/EURUSD/0/5Y/ATM"] =
        vega2.front() * 10.0 / fxspot; // we only have one vega bucket
 
    // sensitivity analysis
    QuantLib::ext::shared_ptr<SensitivityAnalysis> sa = QuantLib::ext::make_shared<SensitivityAnalysis>(
        portfolio, initMarket, Market::defaultConfiguration, data, simMarketData, sensiData, false);
    sa->generateSensitivities();
    map<pair<string, string>, Real> deltaMap;
    map<pair<string, string>, Real> gammaMap;
 
    auto sensiCube = sa->sensiCube();
    for (const auto& tradeId : portfolio->ids()) {
        for (const auto& f : sensiCube->factors()) {
            string des = sensiCube->factorDescription(f);
            deltaMap[make_pair(tradeId, des)] = sensiCube->delta(tradeId, f);
            gammaMap[make_pair(tradeId, des)] = sensiCube->gamma(tradeId, f);
        }
    }
 
    std::vector<ore::analytics::SensitivityScenarioGenerator::ScenarioDescription> scenDesc =
        sa->scenarioGenerator()->scenarioDescriptions();
    Real shiftSize = 1E-5; // shift size
 
    // check deltas
    BOOST_TEST_MESSAGE("Checking deltas...");
    Size foundDeltas = 0, zeroDeltas = 0;
    for (auto const& x : deltaMap) {
        string key = x.first.first + " " + x.first.second;
        Real scaledResult = x.second / shiftSize;
        if (analyticalResultsDelta.count(key) > 0) {
            if (!check(analyticalResultsDelta.at(key), scaledResult))
                BOOST_ERROR("Sensitivity analysis result " << key << " (" << scaledResult
                                                           << ") could not be verified against analytic result ("
                                                           << analyticalResultsDelta.at(key) << ")");
            ++foundDeltas;
        } else {
            if (!close_enough(x.second, 0.0))
                BOOST_ERROR("Sensitivity analysis result " << key << " (" << scaledResult << ") expected to be zero");
            ++zeroDeltas;
        }
    }
    if (foundDeltas != analyticalResultsDelta.size())
        BOOST_ERROR("Mismatch between number of analytical results for delta ("
                    << analyticalResultsDelta.size() << ") and sensitivity results (" << foundDeltas << ")");
    BOOST_TEST_MESSAGE("Checked " << foundDeltas << " deltas against analytical values (and " << zeroDeltas
                                  << " deal-unrelated deltas for zero).");
 
    // check gammas
    BOOST_TEST_MESSAGE("Checking gammas...");
    Size foundGammas = 0, zeroGammas = 0;
    for (auto const& x : gammaMap) {
        string key = x.first.first + " " + x.first.second;
        Real scaledResult = x.second / (shiftSize * shiftSize);
        if (analyticalResultsGamma.count(key) > 0) {
            if (!check(analyticalResultsGamma.at(key), scaledResult))
                BOOST_ERROR("Sensitivity analysis result " << key << " (" << scaledResult
                                                           << ") could not be verified against analytic result ("
                                                           << analyticalResultsGamma.at(key) << ")");
            ++foundGammas;
        } else {
            // the sensi framework produces a Vomma, which we don't check (it isn't produced by the analytic sensi
            // engine)
            if (!close_enough(x.second, 0.0) && key != "5_Swaption_EUR SwaptionVolatility/EUR/47/10Y/10Y/ATM" &&
                key != "7_FxOption_EUR_USD FXVolatility/EURUSD/0/5Y/ATM")
                BOOST_ERROR("Sensitivity analysis result " << key << " (" << scaledResult << ") expected to be zero");
            ++zeroGammas;
        }
    }
    if (foundGammas != analyticalResultsGamma.size())
        BOOST_ERROR("Mismatch between number of analytical results for gamma ("
                    << analyticalResultsGamma.size() << ") and sensitivity results (" << foundGammas << ")");
    BOOST_TEST_MESSAGE("Checked " << foundGammas << " gammas against analytical values (and " << zeroGammas
                                  << " deal-unrelated gammas for zero).");
 
    // check cross gammas
    BOOST_TEST_MESSAGE("Checking cross-gammas...");
    Size foundCrossGammas = 0, zeroCrossGammas = 0;
    for (const auto& [tradeId, trade] : portfolio->trades()) {
        for (auto const& s : scenDesc) {
            if (s.type() == ShiftScenarioGenerator::ScenarioDescription::Type::Cross) {
                string key = tradeId + " " + s.factor1() + " " + s.factor2();
                Real crossGamma = sa->sensiCube()->crossGamma(tradeId, make_pair(s.key1(), s.key2()));
                Real scaledResult = crossGamma / (shiftSize * shiftSize);
                // BOOST_TEST_MESSAGE(key << " " << scaledResult); // debug
                if (analyticalResultsCrossGamma.count(key) > 0) {
                    if (!check(analyticalResultsCrossGamma.at(key), scaledResult))
                        BOOST_ERROR("Sensitivity analysis result "
                                    << key << " (" << scaledResult
                                    << ") could not be verified against analytic result ("
                                    << analyticalResultsCrossGamma.at(key) << ")");
                    ++foundCrossGammas;
                } else {
                    if (!check(crossGamma, 0.0))
                        BOOST_ERROR("Sensitivity analysis result " << key << " (" << scaledResult
                                                                   << ") expected to be zero");
                    ++zeroCrossGammas;
                }
            }
        }
    }
    if (foundCrossGammas != analyticalResultsCrossGamma.size())
        BOOST_ERROR("Mismatch between number of analytical results for gamma ("
                    << analyticalResultsCrossGamma.size() << ") and sensitivity results (" << foundCrossGammas << ")");
    BOOST_TEST_MESSAGE("Checked " << foundCrossGammas << " cross gammas against analytical values (and "
                                  << zeroCrossGammas << " deal-unrelated cross gammas for zero).");
 
    // debug: dump analytical cross gamma results
    // for(auto const& x: analyticalResultsCrossGamma) {
    //     BOOST_TEST_MESSAGE(x.first << " " << x.second);
    // }
 
    ObservationMode::instance().setMode(backupMode);
    IndexManager::instance().clearHistories();
 
    BOOST_CHECK(true);
}

Here is the call graph for this function: