XvaSensitivityAnalyticImpl Class Reference

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

Inheritance diagram for XvaSensitivityAnalyticImpl:

Collaboration diagram for XvaSensitivityAnalyticImpl:

Public Member Functions
	XvaSensitivityAnalyticImpl (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_SENSITIVITY"

Private Member Functions
void	runSensitivity (const QuantLib::ext::shared_ptr< SensitivityScenarioGenerator > &scenarioGenerator, const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader)

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 xvasensitivityanalytic.hpp.

Constructor & Destructor Documentation

XvaSensitivityAnalyticImpl()

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

explicit

Definition at line 32 of file xvasensitivityanalytic.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 37 of file xvasensitivityanalytic.cpp.

                                                                                {
 
    // basic setup
 
    LOG("Running XVA_SENSITIVITY analytic.");
 
    Settings::instance().evaluationDate() = inputs_->asof();
 
    QL_REQUIRE(inputs_->portfolio(), "XvaSensitivityAnalytic::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_SENSI: Build T0 and Sim Markets and Stress Scenario Generator");
 
    analytic()->buildMarket(loader);
 
    LOG("XvaSensitivityAnalytic: Build SimMarket")
    auto simMarket = QuantLib::ext::make_shared<ScenarioSimMarket>(
        analytic()->market(), analytic()->configurations().simMarketParams, marketConfig,
        *analytic()->configurations().curveConfig, *analytic()->configurations().todaysMarketParams,
        inputs_->continueOnError(), analytic()->configurations().sensiScenarioData->useSpreadedTermStructures(), false,
        false, *inputs_->iborFallbackConfig(), true);
 
    LOG("XvaSensitivityAnalytic: Build SensitivityScenarioGenerator")
    
    auto baseScenario = simMarket->baseScenario();
    auto scenarioFactory = QuantLib::ext::make_shared<CloneScenarioFactory>(baseScenario);
    auto scenarioGenerator = QuantLib::ext::make_shared<SensitivityScenarioGenerator>(
        analytic()->configurations().sensiScenarioData, baseScenario, analytic()->configurations().simMarketParams,
        simMarket, scenarioFactory, false);
    simMarket->scenarioGenerator() = scenarioGenerator;
 
    CONSOLE("OK");
 
    // generate the stress scenarios and run dependent xva analytic under each of them
 
    CONSOLE("XVA_SENSI: Running sensi scenarios");
 
    // run stress test
    LOG("Run XVA Sensitivity")
    runSensitivity(scenarioGenerator, loader);
 
    LOG("Running XVA Sensitivity analytic finished.");
}

Here is the call graph for this function:

setUpConfigurations()

void setUpConfigurations ( )

overridevirtual

Reimplemented from Analytic::Impl.

Definition at line 159 of file xvasensitivityanalytic.cpp.

                                                     {
    analytic()->configurations().todaysMarketParams = inputs_->todaysMarketParams();
    analytic()->configurations().simMarketParams = inputs_->xvaSensiSimMarketParams();
    analytic()->configurations().sensiScenarioData = inputs_->xvaSensiScenarioData();
}

Here is the call graph for this function:

runSensitivity()

void runSensitivity ( const QuantLib::ext::shared_ptr< SensitivityScenarioGenerator > &  scenarioGenerator, const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &  loader  )

private

Definition at line 88 of file xvasensitivityanalytic.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());
        auto desc = scenarioGenerator->scenarioDescriptions()[i];
        const auto label = scenario->label();
        QuantLib::ext::shared_ptr<ore::data::InMemoryReport> descReport =
            QuantLib::ext::make_shared<ore::data::InMemoryReport>();
 
        double shiftSize1 = 0.0;
        auto itShiftSize1 = scenarioGenerator->shiftSizes().find(desc.key1());
        if (itShiftSize1 != scenarioGenerator->shiftSizes().end()){
            shiftSize1 = (itShiftSize1->second);
        }
        double shiftSize2 = 0.0;
        auto itShiftSize2 = scenarioGenerator->shiftSizes().find(desc.key2());
        if (itShiftSize2 != scenarioGenerator->shiftSizes().end()) {
            shiftSize2 = (itShiftSize2->second);
        }
        descReport->addColumn("Type", string());
        descReport->addColumn("IsPar", string());
        descReport->addColumn("Factor_1", string());
        descReport->addColumn("ShiftSize_1", double(), 8);
        descReport->addColumn("Factor_2", string());
        descReport->addColumn("ShiftSize_2", double(), 8);
        descReport->addColumn("Currency", string());
        descReport->next();
        descReport->add(ore::data::to_string(desc.type()));
        descReport->add("false");
        descReport->add(desc.factor1());
        descReport->add(shiftSize1);
        descReport->add(desc.factor2());
        descReport->add(shiftSize2);
        descReport->add(inputs_->baseCurrency());
        descReport->end();
        
        try {
            DLOG("Calculate XVA for scenario " << label);
            CONSOLE("XVA_SENSITIVITY: Apply scenario " << label);
            auto newAnalytic = ext::make_shared<XvaAnalytic>(
                inputs_, (label == "BASE" ? nullptr : scenario),
                (label == "BASE" ? nullptr : analytic()->configurations().simMarketParams));
            CONSOLE("XVA_SENSITIVITY: 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(addColumnsToExisitingReport(descReport, rpt));
                }
            }
            // writeCubes(label, newAnalytic);
        } catch (const std::exception& e) {
            StructuredAnalyticsErrorMessage("XvaSensitivity", "XVACalc",
                                            "Error during XVA calc under scenario " + label + ", got " + e.what() +
                                                ". Skip it")
                .log();
        }
    }
    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_SENSITIVITY"

staticconstexpr

Definition at line 34 of file xvasensitivityanalytic.hpp.