XvaStressAnalyticImpl Class Reference

#include <orea/app/analytics/xvastressanalytic.hpp>

Inheritance diagram for XvaStressAnalyticImpl:

Collaboration diagram for XvaStressAnalyticImpl:

Public Member Functions
	XvaStressAnalyticImpl (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
void	runAnalytic (const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader, const std::set< std::string > &runTypes={}) override
void	setUpConfigurations () override
Public Member Functions inherited from Analytic::Impl
	Impl ()
	Impl (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
virtual	~Impl ()
virtual void	runAnalytic (const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader, const std::set< std::string > &runTypes={})=0
virtual void	setUpConfigurations ()
virtual QuantLib::ext::shared_ptr< ore::data::EngineFactory >	engineFactory ()
	build an engine factory More...
void	setLabel (const string &label)
const std::string &	label () const
void	setAnalytic (Analytic *analytic)
Analytic *	analytic () const
void	setInputs (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
bool	generateAdditionalResults () const
void	setGenerateAdditionalResults (const bool generateAdditionalResults)
bool	hasDependentAnalytic (const std::string &key)
template<class T >
QuantLib::ext::shared_ptr< T >	dependentAnalytic (const std::string &key) const
QuantLib::ext::shared_ptr< Analytic >	dependentAnalytic (const std::string &key) const
const std::map< std::string, QuantLib::ext::shared_ptr< Analytic > > &	dependentAnalytics () const
void	addDependentAnalytic (const std::string &key, const QuantLib::ext::shared_ptr< Analytic > &analytic)
std::vector< QuantLib::ext::shared_ptr< Analytic > >	allDependentAnalytics () const
virtual std::vector< QuantLib::Date >	additionalMarketDates () const

Static Public Attributes
static constexpr const char *	LABEL = "XVA_STRESS"

Private Member Functions
void	runStressTest (const QuantLib::ext::shared_ptr< ore::analytics::StressScenarioGenerator > &scenarioGenerator, const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader)
void	writeCubes (const std::string &label, const QuantLib::ext::shared_ptr< XvaAnalytic > &xvaAnalytic)
void	concatReports (const std::map< std::string, std::vector< QuantLib::ext::shared_ptr< ore::data::InMemoryReport > > > &xvaReports)

Additional Inherited Members
Protected Attributes inherited from Analytic::Impl
QuantLib::ext::shared_ptr< InputParameters >	inputs_
std::string	label_
	label for logging purposes primarily More...
std::map< std::string, QuantLib::ext::shared_ptr< Analytic > >	dependentAnalytics_

Detailed Description

Definition at line 32 of file xvastressanalytic.hpp.

Constructor & Destructor Documentation

XvaStressAnalyticImpl()

XvaStressAnalyticImpl ( const QuantLib::ext::shared_ptr< InputParameters > &  inputs )

explicit

Definition at line 78 of file xvastressanalytic.cpp.

    : Analytic::Impl(inputs) {
    setLabel(LABEL);
}

Here is the call graph for this function:

Member Function Documentation

runAnalytic()

void runAnalytic ( const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &  loader, const std::set< std::string > &  runTypes = {}  )

overridevirtual

Implements Analytic::Impl.

Definition at line 83 of file xvastressanalytic.cpp.

                                                                           {
 
    // basic setup
 
    LOG("Running XVA Stress analytic.");
 
    Settings::instance().evaluationDate() = inputs_->asof();
 
    QL_REQUIRE(inputs_->portfolio(), "XvaStressAnalytic::run: No portfolio loaded.");
 
    Settings::instance().evaluationDate() = inputs_->asof();
    std::string marketConfig = inputs_->marketConfig("pricing"); // FIXME
 
    auto xvaAnalytic = dependentAnalytic<XvaAnalytic>("XVA");
 
    // build t0, sim market, stress scenario generator
 
    CONSOLEW("XVA_STRESS: Build T0 and Sim Markets and Stress Scenario Generator");
 
    analytic()->buildMarket(loader);
 
    QuantLib::ext::shared_ptr<StressTestScenarioData> scenarioData = inputs_->xvaStressScenarioData();
    if (scenarioData != nullptr && scenarioData->hasScenarioWithParShifts()) {
        try {
            ParStressTestConverter converter(
                inputs_->asof(), analytic()->configurations().todaysMarketParams,
                analytic()->configurations().simMarketParams, analytic()->configurations().sensiScenarioData,
                analytic()->configurations().curveConfig, analytic()->market(), inputs_->iborFallbackConfig());
            scenarioData = converter.convertStressScenarioData(scenarioData);
            analytic()->stressTests()[label()]["stress_ZeroStressData"] = scenarioData;
        } catch (const std::exception& e) {
            scenarioData = inputs_->xvaStressScenarioData();
            StructuredAnalyticsErrorMessage(label(), "ParConversionFailed", e.what()).log();
        }
    }
 
    LOG("XVA Stress: Build SimMarket and StressTestScenarioGenerator")
    auto simMarket = QuantLib::ext::make_shared<ScenarioSimMarket>(
        analytic()->market(), analytic()->configurations().simMarketParams, marketConfig,
        *analytic()->configurations().curveConfig, *analytic()->configurations().todaysMarketParams,
        inputs_->continueOnError(), scenarioData->useSpreadedTermStructures(), false, false,
        *inputs_->iborFallbackConfig(), true);
 
    auto baseScenario = simMarket->baseScenario();
    auto scenarioFactory = QuantLib::ext::make_shared<CloneScenarioFactory>(baseScenario);
    auto scenarioGenerator = QuantLib::ext::make_shared<StressScenarioGenerator>(
        scenarioData, baseScenario, analytic()->configurations().simMarketParams, simMarket, scenarioFactory,
        simMarket->baseScenarioAbsolute());
    simMarket->scenarioGenerator() = scenarioGenerator;
 
    CONSOLE("OK");
 
    // generate the stress scenarios and run dependent xva analytic under each of them
 
    CONSOLE("XVA_STRESS: Running stress scenarios");
 
    // run stress test
    LOG("Run XVA Stresstest")
    runStressTest(scenarioGenerator, loader);
 
    LOG("Running XVA Stress analytic finished.");
}

Here is the call graph for this function:

setUpConfigurations()

void setUpConfigurations ( )

overridevirtual

Reimplemented from Analytic::Impl.

Definition at line 192 of file xvastressanalytic.cpp.

                                                {
    analytic()->configurations().todaysMarketParams = inputs_->todaysMarketParams();
    analytic()->configurations().simMarketParams = inputs_->xvaStressSimMarketParams();
    analytic()->configurations().sensiScenarioData = inputs_->xvaStressSensitivityScenarioData();
}

Here is the call graph for this function:

runStressTest()

void runStressTest ( const QuantLib::ext::shared_ptr< ore::analytics::StressScenarioGenerator > &  scenarioGenerator, const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &  loader  )

private

Definition at line 147 of file xvastressanalytic.cpp.

                                                                                                      {
 
    std::map<std::string, std::vector<QuantLib::ext::shared_ptr<ore::data::InMemoryReport>>> xvaReports;
    for (size_t i = 0; i < scenarioGenerator->samples(); ++i) {
        auto scenario = scenarioGenerator->next(inputs_->asof());
        const std::string& label = scenario != nullptr ? scenario->label() : std::string();
        try {
            DLOG("Calculate XVA for scenario " << label);
            CONSOLE("XVA_STRESS: Apply scenario " << label);
            auto newAnalytic = ext::make_shared<XvaAnalytic>(
                inputs_, (label == "BASE" ? nullptr : scenario),
                (label == "BASE" ? nullptr : analytic()->configurations().simMarketParams));
            CONSOLE("XVA_STRESS: Calculate Exposure and XVA")
            newAnalytic->runAnalytic(loader, {"EXPOSURE", "XVA"});
            // Collect exposure and xva reports
            for (auto& [name, rpt] : newAnalytic->reports()["XVA"]) {
                // add scenario column to report and copy it, concat it later
                if (boost::starts_with(name, "exposure") || boost::starts_with(name, "xva")) {
                    DLOG("Save and extend report " << name);
                    xvaReports[name].push_back(addColumnToExisitingReport("Scenario", label, rpt));
                }
            }
            writeCubes(label, newAnalytic);
        } catch (const std::exception& e) {
            StructuredAnalyticsErrorMessage("XvaStress", "XVACalc",
                                            "Error during XVA calc under scenario " + label + ", got " + e.what() +
                                                ". Skip it")
                .log();
        }
    }
    concatReports(xvaReports);
}

Here is the call graph for this function:

Here is the caller graph for this function:

writeCubes()

void writeCubes ( const std::string &  label, const QuantLib::ext::shared_ptr< XvaAnalytic > &  xvaAnalytic  )

private

Definition at line 33 of file xvastressanalytic.cpp.

                                                                                              {
    if (!inputs_->xvaStressWriteCubes() || xvaAnalytic == nullptr) {
        return;
    }
 
    if (inputs_->rawCubeOutput()) {
        DLOG("Write raw cube under scenario " << label);
        // analytic()->reports()["XVA_STRESS"]["rawcube_" + label] = xvaAnalytic->reports()["XVA"]["rawcube"];
        xvaAnalytic->reports()["XVA"]["rawcube"]->toFile(inputs_->resultsPath().string() + "/rawcube_" + label +
                                                         ".csv");
    }
 
    if (inputs_->netCubeOutput()) {
        DLOG("Write raw cube under scenario " << label);
        // analytic()->reports()["XVA_STRESS"]["netcube_" + label] = xvaAnalytic->reports()["XVA"]["netcube"];
        xvaAnalytic->reports()["XVA"]["netcube"]->toFile(inputs_->resultsPath().string() + "/netcube_" + label +
                                                         ".csv");
    }
 
    if (inputs_->writeCube()) {
        const auto& cubes = xvaAnalytic->npvCubes()["XVA"];
        for (const auto& [name, cube] : cubes) {
            DLOG("Write cube under scenario " << name << " for scenario" << label);
            // analytic()->npvCubes()["XVA_STRESS"][name + "_" + label] = cube;
            NPVCubeWithMetaData r;
            r.cube = cube;
            if (name == "cube") {
                // store meta data together with npv cube
                r.scenarioGeneratorData = inputs_->scenarioGeneratorData();
                r.storeFlows = inputs_->storeFlows();
                r.storeCreditStateNPVs = inputs_->storeCreditStateNPVs();
            }
            saveCube(inputs_->resultsPath().string() + "/" + name + "_" + label + ".csv.gz", r);
        }
    }
 
    if (inputs_->writeScenarios()) {
        DLOG("Write scenario report under scenario " << label);
        // analytic()->reports()["XVA_STRESS"]["scenario" + label] = xvaAnalytic->reports()["XVA"]["scenario"];
        xvaAnalytic->reports()["XVA"]["scenario"]->toFile(inputs_->resultsPath().string() + "/scenario" + label +
                                                          ".csv");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

concatReports()

void concatReports ( const std::map< std::string, std::vector< QuantLib::ext::shared_ptr< ore::data::InMemoryReport > > > &  xvaReports )

private

Definition at line 181 of file xvastressanalytic.cpp.

                                                                                                  {
    DLOG("Concat exposure and xva reports");
    for (auto& [name, reports] : xvaReports) {
        auto report = concatenateReports(reports);
        if (report != nullptr) {
            analytic()->reports()[label()][name] = report;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

LABEL

constexpr const char* LABEL = "XVA_STRESS"

staticconstexpr

Definition at line 34 of file xvastressanalytic.hpp.