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

Inheritance diagram for XvaAnalyticImpl:

Collaboration diagram for XvaAnalyticImpl:

Public Member Functions
	XvaAnalyticImpl (const QuantLib::ext::shared_ptr< InputParameters > &inputs, const QuantLib::ext::shared_ptr< Scenario > &offsetScenario=nullptr, const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &offsetSimMarketParams=nullptr)

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

void	setUpConfigurations () override

void	checkConfigurations (const QuantLib::ext::shared_ptr< Portfolio > &portfolio)

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"

Protected Member Functions
QuantLib::ext::shared_ptr< ore::data::EngineFactory >	engineFactory () override
	build an engine factory More...

void	buildScenarioSimMarket ()

void	buildCrossAssetModel (bool continueOnError)

void	buildScenarioGenerator (bool continueOnError)

void	initCubeDepth ()

void	initCube (QuantLib::ext::shared_ptr< NPVCube > &cube, const std::set< std::string > &ids, Size cubeDepth)

void	initClassicRun (const QuantLib::ext::shared_ptr< Portfolio > &portfolio)

void	buildClassicCube (const QuantLib::ext::shared_ptr< Portfolio > &portfolio)

QuantLib::ext::shared_ptr< Portfolio >	classicRun (const QuantLib::ext::shared_ptr< Portfolio > &portfolio)

QuantLib::ext::shared_ptr< EngineFactory >	amcEngineFactory (const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &cam, const std::vector< Date > &grid)

void	buildAmcPortfolio ()

void	amcRun (bool doClassicRun)

void	runPostProcessor ()

Matrix	creditStateCorrelationMatrix () const

Protected Attributes
QuantLib::ext::shared_ptr< ScenarioSimMarket >	simMarket_

QuantLib::ext::shared_ptr< ScenarioSimMarket >	simMarketCalibration_

QuantLib::ext::shared_ptr< ScenarioSimMarket >	offsetSimMarket_

QuantLib::ext::shared_ptr< EngineFactory >	engineFactory_

QuantLib::ext::shared_ptr< CrossAssetModel >	model_

QuantLib::ext::shared_ptr< ScenarioGenerator >	scenarioGenerator_

QuantLib::ext::shared_ptr< Portfolio >	amcPortfolio_

QuantLib::ext::shared_ptr< Portfolio >	classicPortfolio_

QuantLib::ext::shared_ptr< NPVCube >	cube_

QuantLib::ext::shared_ptr< NPVCube >	nettingSetCube_

QuantLib::ext::shared_ptr< NPVCube >	cptyCube_

QuantLib::ext::shared_ptr< NPVCube >	amcCube_

QuantLib::RelinkableHandle< AggregationScenarioData >	scenarioData_

QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpreter_

QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator >	dimCalculator_

QuantLib::ext::shared_ptr< PostProcess >	postProcess_

QuantLib::ext::shared_ptr< Scenario >	offsetScenario_

QuantLib::ext::shared_ptr< ScenarioSimMarketParameters >	offsetSimMarketParams_

Size	cubeDepth_ = 0

QuantLib::ext::shared_ptr< DateGrid >	grid_

Size	samples_ = 0

bool	runSimulation_ = false

bool	runXva_ = false

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 30 of file xvaanalytic.hpp.

Constructor & Destructor Documentation

◆ XvaAnalyticImpl()

XvaAnalyticImpl	(	const QuantLib::ext::shared_ptr< InputParameters > &	inputs,
		const QuantLib::ext::shared_ptr< Scenario > &	offsetScenario = `nullptr`,
		const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &	offsetSimMarketParams = `nullptr`
	)

explicit

Definition at line 34 of file xvaanalytic.hpp.

        : Analytic::Impl(inputs), offsetScenario_(offsetScenario), offsetSimMarketParams_(offsetSimMarketParams) {
        QL_REQUIRE(!((offsetScenario_ == nullptr) ^ (offsetSimMarketParams_ == nullptr)),
                   "Need offsetScenario and corresponding simMarketParameter");
        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 652 of file xvaanalytic.cpp.

                                                                 {
 
    if(inputs_->amcCg()) {
        LOG("XVA analytic is running with amc cg engine (experimental).");
        // note: market configs both set to simulation, see note in xvaenginecg, we'd need inccy config in sim market there...
        XvaEngineCG engine(inputs_->nThreads(), inputs_->asof(), loader, inputs_->curveConfigs().get(),
                           analytic()->configurations().todaysMarketParams,
                           analytic()->configurations().simMarketParams, inputs_->amcPricingEngine(),
                           inputs_->crossAssetModelData(), inputs_->scenarioGeneratorData(), inputs_->portfolio(),
                           inputs_->marketConfig("simulation"), inputs_->marketConfig("simulation"),
                           inputs_->xvaCgSensiScenarioData(), inputs_->refDataManager(), *inputs_->iborFallbackConfig(),
                           inputs_->xvaCgBumpSensis());
 
        analytic()->reports()["XVA"]["xvacg-exposure"] = engine.exposureReport();
    analytic()->reports()["XVA"]["xvacg-cva-sensi-scenario"] = engine.sensiReport();
    return;
    }
 
    LOG("XVA analytic called with asof " << io::iso_date(inputs_->asof()));
    ProgressMessage("Running XVA Analytic", 0, 1).log();
 
    if (runTypes.find("EXPOSURE") != runTypes.end() || runTypes.empty())
        runSimulation_ = true;
 
    if (runTypes.find("XVA") != runTypes.end() || runTypes.empty())
        runXva_ = true;
 
    Settings::instance().evaluationDate() = inputs_->asof();
    ObservationMode::instance().setMode(inputs_->exposureObservationModel());
 
    const string msg = "XVA: Build Today's Market";
    LOG(msg);
    CONSOLEW(msg);
    ProgressMessage(msg, 0, 1).log();
    analytic()->buildMarket(loader);
    CONSOLE("OK");
    ProgressMessage(msg, 1, 1).log();
    
    grid_ = analytic()->configurations().scenarioGeneratorData->getGrid();
    cubeInterpreter_ = QuantLib::ext::make_shared<CubeInterpretation>(
        inputs_->storeFlows(), analytic()->configurations().scenarioGeneratorData->withCloseOutLag(), scenarioData_,
        grid_, inputs_->storeCreditStateNPVs(), inputs_->flipViewXVA());
 
    if (runSimulation_) {
        LOG("XVA: Build simulation market");
        buildScenarioSimMarket();
 
        LOG("XVA: Build Scenario Generator");
        auto globalParams = inputs_->simulationPricingEngine()->globalParameters();
        auto continueOnCalErr = globalParams.find("ContinueOnCalibrationError");
        bool continueOnErr = (continueOnCalErr != globalParams.end()) && parseBool(continueOnCalErr->second);        
        buildScenarioGenerator(continueOnErr);
 
        LOG("XVA: Attach Scenario Generator to ScenarioSimMarket");
        simMarket_->scenarioGenerator() = scenarioGenerator_;
 
        // We may have to build two cubes below for complementary sub-portfolios, a classical cube and an AMC cube
        bool doClassicRun = true;
        bool doAmcRun = false;
 
        // Initialize the residual "classical" portfolio that we do not process using AMC
        auto residualPortfolio = QuantLib::ext::make_shared<Portfolio>(inputs_->buildFailedTrades());
 
        if (inputs_->amc()) {
            // Build a separate sub-portfolio for the AMC cube generation and perform its training
            buildAmcPortfolio();
 
            // Build the residual portfolio for the classic cube generation, i.e. strip out the AMC part
            for (auto const& [tradeId, trade] : inputs_->portfolio()->trades()) {
                if (inputs_->amcTradeTypes().find(trade->tradeType()) == inputs_->amcTradeTypes().end())
                    residualPortfolio->add(trade);
            }
 
            LOG("AMC portfolio size " << amcPortfolio_->size());
            LOG("Residual portfolio size " << residualPortfolio->size());
 
            doAmcRun = !amcPortfolio_->trades().empty();
            doClassicRun = !residualPortfolio->trades().empty();
        } else {
            for (const auto& [tradeId, trade] : inputs_->portfolio()->trades())
                residualPortfolio->add(trade);
        }
 
        /********************************************************************************
         * This is where we build cubes and the "classic" valuation work is done
         * The bulk of the AMC work is done before in the AMC portfolio building/training
         ********************************************************************************/
 
        if (doAmcRun)
            amcRun(doClassicRun);
        else
            amcPortfolio_ = QuantLib::ext::make_shared<Portfolio>(inputs_->buildFailedTrades());
        
        if (doClassicRun)
            classicPortfolio_ = classicRun(residualPortfolio);
        else
            classicPortfolio_ = QuantLib::ext::make_shared<Portfolio>(inputs_->buildFailedTrades());
 
        /***************************************************
         * We may have two cubes now that need to be merged
         ***************************************************/
        
        if (doClassicRun && doAmcRun) {
            LOG("Joining classical and AMC cube");
            cube_ = QuantLib::ext::make_shared<JointNPVCube>(cube_, amcCube_);
        } else if (!doClassicRun && doAmcRun) {
            LOG("We have generated an AMC cube only");
            cube_ = amcCube_;
        } else {
            WLOG("We have generated a classic cube only");
        }
        
        LOG("NPV cube generation completed");
 
        /***********************************************************************
         * We may have two non-empty portfolios to be merged for post processing
         ***********************************************************************/
 
        LOG("Classic portfolio size " << classicPortfolio_->size());
        LOG("AMC portfolio size " << amcPortfolio_->size());
        auto newPortfolio = QuantLib::ext::make_shared<Portfolio>();
        for (const auto& [tradeId, trade] : classicPortfolio_->trades())
            newPortfolio->add(trade);
        for (const auto& [tradeId, trade] : amcPortfolio_->trades())
            newPortfolio->add(trade);
        LOG("Total portfolio size " << newPortfolio->size());
        if (newPortfolio->size() < inputs_->portfolio()->size()) {
            ALOG("input portfolio size is " << inputs_->portfolio()->size() << 
                ", but we have built only " << newPortfolio->size() << " trades");
        }
        analytic()->setPortfolio(newPortfolio);
    } else { // runSimulation_
 
        // build the portfolio linked to today's market
        analytic()->buildPortfolio();
 
        // ... and load a pre-built cube for post-processing
 
        LOG("Skip cube generation, load input cubes for XVA");
        const string msg = "XVA: Load Cubes";
        CONSOLEW(msg);
        ProgressMessage(msg, 0, 1).log();
        QL_REQUIRE(inputs_->cube(), "XVA without EXPOSURE requires an NPV cube as input");
        cube_= inputs_->cube();
        QL_REQUIRE(inputs_->mktCube(), "XVA without EXPOSURE requires a market cube as input");
        scenarioData_.linkTo(inputs_->mktCube());
        if (inputs_->nettingSetCube())
            nettingSetCube_= inputs_->nettingSetCube();
        if (inputs_->cptyCube())
            cptyCube_ = inputs_->cptyCube();
        CONSOLE("OK");
        ProgressMessage(msg, 1, 1).log();
    }
 
    MEM_LOG;
 
    // Return the cubes to serialalize
    if (inputs_->writeCube()) {
        analytic()->npvCubes()["XVA"]["cube"] = cube_;
        analytic()->mktCubes()["XVA"]["scenariodata"] = *scenarioData_;
        if (nettingSetCube_) {
            analytic()->npvCubes()["XVA"]["nettingsetcube"] = nettingSetCube_;
        }
        if (cptyCube_) {
            analytic()->npvCubes()["XVA"]["cptycube"] = cptyCube_;
        }
    }
 
    // Generate cube reports to inspect
    if (inputs_->rawCubeOutput()) {
        map<string, string> nettingSetMap = analytic()->portfolio()->nettingSetMap();
        auto report = QuantLib::ext::make_shared<InMemoryReport>();
        ReportWriter(inputs_->reportNaString()).writeCube(*report, cube_, nettingSetMap);
        analytic()->reports()["XVA"]["rawcube"] = report;
    }
 
    if (runXva_) {
 
        /*********************************************************************
         * This is where the aggregation work is done: call the post-processor
         *********************************************************************/
 
        string msg = "XVA: Aggregation";
        CONSOLEW(msg);
        ProgressMessage(msg, 0, 1).log();
        runPostProcessor();
        CONSOLE("OK");
        ProgressMessage(msg, 1, 1).log();
 
        /******************************************************
         * Finally generate various (in-memory) reports/outputs
         ******************************************************/
 
        msg = "XVA: Reports";
        CONSOLEW(msg);
        ProgressMessage(msg, 0, 1).log();
        LOG("Generating XVA reports and cube outputs");
 
        if (inputs_->exposureProfilesByTrade()) {
            for (const auto& [tradeId, tradeIdCubePos] : postProcess_->tradeIds()) {
                auto report = QuantLib::ext::make_shared<InMemoryReport>();
                try {
                    ReportWriter(inputs_->reportNaString()).writeTradeExposures(*report, postProcess_, tradeId);
                    analytic()->reports()["XVA"]["exposure_trade_" + tradeId] = report;
                } catch (const std::exception& e) {
                    StructuredAnalyticsErrorMessage("Trade Exposure Report", "Error processing trade.", e.what(),
                                                    {{"tradeId", tradeId}})
                        .log();
                }
            }
        }
 
        if (inputs_->exposureProfiles()) {
            for (auto [nettingSet, nettingSetPosInCube] : postProcess_->nettingSetIds()) {
                auto exposureReport = QuantLib::ext::make_shared<InMemoryReport>();
                try {
                    ReportWriter(inputs_->reportNaString())
                        .writeNettingSetExposures(*exposureReport, postProcess_, nettingSet);
                    analytic()->reports()["XVA"]["exposure_nettingset_" + nettingSet] = exposureReport;
                } catch (const std::exception& e) {
                    StructuredAnalyticsErrorMessage("Netting Set Exposure Report", "Error processing netting set.",
                                                    e.what(), {{"nettingSetId", nettingSet}})
                        .log();
                }
 
                auto colvaReport = QuantLib::ext::make_shared<InMemoryReport>();
                try {
                    ReportWriter(inputs_->reportNaString())
                        .writeNettingSetColva(*colvaReport, postProcess_, nettingSet);
                    analytic()->reports()["XVA"]["colva_nettingset_" + nettingSet] = colvaReport;
                } catch (const std::exception& e) {
                    StructuredAnalyticsErrorMessage("Netting Set Colva Report", "Error processing netting set.",
                                                    e.what(), {{"nettingSetId", nettingSet}})
                        .log();
                }
 
                auto cvaSensiReport = QuantLib::ext::make_shared<InMemoryReport>();
                try {
                    ReportWriter(inputs_->reportNaString())
                        .writeNettingSetCvaSensitivities(*cvaSensiReport, postProcess_, nettingSet);
                    analytic()->reports()["XVA"]["cva_sensitivity_nettingset_" + nettingSet] = cvaSensiReport;
                } catch (const std::exception& e) {
                    StructuredAnalyticsErrorMessage("Cva Sensi Report", "Error processing netting set.", e.what(),
                                                    {{"nettingSetId", nettingSet}})
                        .log();
                }
            }
        }
 
        auto xvaReport = QuantLib::ext::make_shared<InMemoryReport>();
        ReportWriter(inputs_->reportNaString())
            .writeXVA(*xvaReport, inputs_->exposureAllocationMethod(), analytic()->portfolio(), postProcess_);
        analytic()->reports()["XVA"]["xva"] = xvaReport;
 
        if (inputs_->netCubeOutput()) {
            auto report = QuantLib::ext::make_shared<InMemoryReport>();
            ReportWriter(inputs_->reportNaString()).writeCube(*report, postProcess_->netCube());
            analytic()->reports()["XVA"]["netcube"] = report;
        }
 
        if (inputs_->dimAnalytic() || inputs_->mvaAnalytic()) {
            // Generate DIM evolution report
            auto dimEvolutionReport = QuantLib::ext::make_shared<InMemoryReport>();
            postProcess_->exportDimEvolution(*dimEvolutionReport);
            analytic()->reports()["XVA"]["dim_evolution"] = dimEvolutionReport;
 
            // Generate DIM regression reports
            vector<QuantLib::ext::shared_ptr<ore::data::Report>> dimRegReports;
            for (Size i = 0; i < inputs_->dimOutputGridPoints().size(); ++i) {
                auto rep = QuantLib::ext::make_shared<InMemoryReport>();
                dimRegReports.push_back(rep);
                analytic()->reports()["XVA"]["dim_regression_" + std::to_string(i)] = rep;
            }
            postProcess_->exportDimRegression(inputs_->dimOutputNettingSet(), inputs_->dimOutputGridPoints(),
                                              dimRegReports);
        }
 
        if (inputs_->creditMigrationAnalytic()) {
            QL_REQUIRE(
                postProcess_->creditMigrationPdf().size() == inputs_->creditMigrationTimeSteps().size(),
                "XvaAnalyticImpl::runAnalytic(): inconsistent post process results for credit migration pdf / cdf ("
                    << postProcess_->creditMigrationPdf().size() << ") and input credit migration time steps ("
                    << inputs_->creditMigrationTimeSteps().size() << ")");
            for (Size i = 0; i < postProcess_->creditMigrationPdf().size(); ++i) {
                auto rep = QuantLib::ext::make_shared<InMemoryReport>();
                analytic()
                    ->reports()["XVA"]["credit_migration_" + std::to_string(inputs_->creditMigrationTimeSteps()[i])] =
                    rep;
                (*rep)
                    .addColumn("upperBucketBound", double(), 6)
                    .addColumn("pdf", double(), 8)
                    .addColumn("cdf", double(), 8);
                for (Size j = 0; j < postProcess_->creditMigrationPdf()[i].size(); ++j) {
                    (*rep)
                        .next()
                        .add(postProcess_->creditMigrationUpperBucketBounds()[j])
                        .add(postProcess_->creditMigrationPdf()[i][j])
                        .add(postProcess_->creditMigrationCdf()[i][j]);
                }
                rep->end();
            }
        }
 
        CONSOLE("OK");
        ProgressMessage(msg, 1, 1).log();
    }
 
    // reset that mode
    ObservationMode::instance().setMode(inputs_->observationModel());
    ProgressMessage("Running XVA Analytic", 1, 1).log();
}

Here is the call graph for this function:

◆ setUpConfigurations()

void setUpConfigurations ( )

overridevirtual

Reimplemented from Analytic::Impl.

Definition at line 49 of file xvaanalytic.cpp.

                                          {
    LOG("XvaAnalytic::setUpConfigurations() called");
    analytic()->configurations().todaysMarketParams = inputs_->todaysMarketParams();
    analytic()->configurations().simMarketParams = inputs_->exposureSimMarketParams();
    analytic()->configurations().scenarioGeneratorData = inputs_->scenarioGeneratorData();
    analytic()->configurations().crossAssetModelData = inputs_->crossAssetModelData();
}

Here is the call graph for this function:

◆ checkConfigurations()

void checkConfigurations ( const QuantLib::ext::shared_ptr< Portfolio > & portfolio )

Definition at line 57 of file xvaanalytic.cpp.

                                                                                            {
    //find the unique nettingset keys in portfolio
    std::map<std::string, std::string> nettingSetMap =  portfolio->nettingSetMap();
    std::vector<std::string> nettingSetKeys;
    for(std::map<std::string, std::string>::iterator it = nettingSetMap.begin(); it != nettingSetMap.end(); ++it)
        nettingSetKeys.push_back(it->second);
    //unique nettingset keys
    sort(nettingSetKeys.begin(), nettingSetKeys.end());
    nettingSetKeys.erase(unique( nettingSetKeys.begin(), nettingSetKeys.end() ), nettingSetKeys.end());
    //controls on calcType and grid type, if netting-set has an active CSA in place
    for(auto const& key : nettingSetKeys){
        LOG("For netting-set "<<key<<"CSA flag is "<<inputs_->nettingSetManager()->get(key)->activeCsaFlag());
        if (inputs_->nettingSetManager()->get(key)->activeCsaFlag()){
            string calculationType = inputs_->collateralCalculationType();
            if (analytic()->configurations().scenarioGeneratorData->withCloseOutLag()){
                QL_REQUIRE(calculationType == "NoLag", "For nettingSetID "<<key<< ", CSA is active and a close-out grid is configured in the simulation.xml. Therefore, calculation type "<<calculationType<<" is not admissable. It must be set to NoLag!");
                LOG("For netting-set "<<key<<", calculation type is "<<calculationType);
            }
            else{
                QL_REQUIRE(calculationType != "NoLag", "For nettingSetID "<<key<< ", CSA is active and a close-out grid is not configured in the simulation.xml. Therefore, calculation type " <<calculationType<<" is not admissable. It must be set to either Symmetric or AsymmerticCVA or AsymmetricDVA!" );
                LOG("For netting-set "<<key<<", calculation type is "<<calculationType);
            }
            if (analytic()->configurations().scenarioGeneratorData->withCloseOutLag() && analytic()->configurations().scenarioGeneratorData->closeOutLag() != 0*Days){
                Period mpor_simulation = analytic()->configurations().scenarioGeneratorData->closeOutLag();                   
                Period mpor_netting = inputs_->nettingSetManager()->get(key)->csaDetails()->marginPeriodOfRisk();
                if (mpor_simulation != mpor_netting)
                    StructuredAnalyticsWarningMessage(
                        "XvaAnalytic", "Inconsistent MPoR period",
                        "For netting set " + key + ", close-out lag is not consistent with the netting-set's mpor ")
                        .log();
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ engineFactory()

QuantLib::ext::shared_ptr< EngineFactory > engineFactory ( )

overrideprotectedvirtual

build an engine factory

Reimplemented from Analytic::Impl.

Definition at line 92 of file xvaanalytic.cpp.

                                                                    {
    LOG("XvaAnalytic::engineFactory() called");
    QuantLib::ext::shared_ptr<EngineData> edCopy = QuantLib::ext::make_shared<EngineData>(*inputs_->simulationPricingEngine());
    edCopy->globalParameters()["GenerateAdditionalResults"] = inputs_->outputAdditionalResults() ? "true" : "false";
    edCopy->globalParameters()["RunType"] = "Exposure";
    map<MarketContext, string> configurations;
    configurations[MarketContext::irCalibration] = inputs_->marketConfig("lgmcalibration");    
    configurations[MarketContext::fxCalibration] = inputs_->marketConfig("fxcalibration");
    configurations[MarketContext::pricing] = inputs_->marketConfig("pricing");
    //configurations[MarketContext::simulation] = inputs_->marketConfig("simulation");
    std::vector<QuantLib::ext::shared_ptr<EngineBuilder>> extraEngineBuilders; 
    std::vector<QuantLib::ext::shared_ptr<LegBuilder>> extraLegBuilders;
 
    if (runSimulation_) {
        // link to the sim market here
        QL_REQUIRE(simMarket_, "Simulaton market not set");
        engineFactory_ = QuantLib::ext::make_shared<EngineFactory>(edCopy, simMarket_, configurations,
                                                           inputs_->refDataManager(), *inputs_->iborFallbackConfig());
    } else {
        // we just link to today's market if simulation is not required
        engineFactory_ = QuantLib::ext::make_shared<EngineFactory>(edCopy, analytic()->market(), configurations, inputs_->refDataManager(),
                                                           *inputs_->iborFallbackConfig());
    }
    return engineFactory_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildScenarioSimMarket()

void buildScenarioSimMarket ( )

protected

Definition at line 119 of file xvaanalytic.cpp.

                                             {
    
    std::string configuration = inputs_->marketConfig("simulation");
    simMarket_ = QuantLib::ext::make_shared<ScenarioSimMarket>(
            analytic()->market(),
            analytic()->configurations().simMarketParams,
            QuantLib::ext::make_shared<FixingManager>(inputs_->asof()),
            configuration,
            *inputs_->curveConfigs().get(),
            *analytic()->configurations().todaysMarketParams,
            inputs_->continueOnError(), 
            false, true, false,
            *inputs_->iborFallbackConfig(),
            false, offsetScenario_);
 
    if(offsetScenario_ == nullptr){
        simMarketCalibration_ = simMarket_;
        offsetSimMarket_ = simMarket_;
    } else{
        // set useSpreadedTermstructure to true, yield better results in calibration of the CAM
        simMarketCalibration_ = QuantLib::ext::make_shared<ScenarioSimMarket>(
            analytic()->market(), analytic()->configurations().simMarketParams,
            QuantLib::ext::make_shared<FixingManager>(inputs_->asof()), configuration, *inputs_->curveConfigs().get(),
            *analytic()->configurations().todaysMarketParams, inputs_->continueOnError(), true, true, false,
            *inputs_->iborFallbackConfig(), false, offsetScenario_);
 
        // Create a third market used for AMC and Postprocessor, holds a larger simmarket, e.g. default curves
        offsetSimMarket_ = QuantLib::ext::make_shared<ScenarioSimMarket>(
            analytic()->market(), offsetSimMarketParams_, QuantLib::ext::make_shared<FixingManager>(inputs_->asof()),
            configuration, *inputs_->curveConfigs().get(), *analytic()->configurations().todaysMarketParams,
            inputs_->continueOnError(), true, true, false, *inputs_->iborFallbackConfig(), false, offsetScenario_);
    
        TLOG("XvaAnalytic: Offset Scenario used in building SimMarket");
        TLOG("XvaAnalytic: Offset scenario is absolute = " << offsetScenario_->isAbsolute());
        TLOG("RfKey,OffsetScenarioValue");
        for (const auto& key : offsetScenario_->keys()) {
            TLOG(key << " : " << offsetScenario_->get(key));
        }
    }
    
    TLOG("XvaAnalytic:Finished building Scenario SimMarket");
    TLOG("RfKey,BaseScenarioValue,BaseScenarioAbsValue");
    for (const auto& key : simMarket_->baseScenario()->keys()) {
        TLOG(key << "," << simMarket_->baseScenario()->get(key) << "," << simMarket_->baseScenarioAbsolute()->get(key));
    }
    TLOG("XvaAnalytic: Finished building Scenario SimMarket for model calibration (useSpreadedTermStructure)");
    TLOG("RfKey,BaseScenarioValue,BaseScenarioAbsValue");
    for (const auto& key : simMarketCalibration_->baseScenario()->keys()) {
        TLOG(key << "," << simMarketCalibration_->baseScenario()->get(key) << ","
                 << simMarketCalibration_->baseScenarioAbsolute()->get(key));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildCrossAssetModel()

void buildCrossAssetModel ( bool continueOnError )

protected

Definition at line 195 of file xvaanalytic.cpp.

                                                                                {
    LOG("XVA: Build Simulation Model (continueOnCalibrationError = "
        << std::boolalpha << continueOnCalibrationError << ")");
    ext::shared_ptr<Market> market = offsetScenario_ != nullptr ? simMarketCalibration_ : analytic()->market();
    QL_REQUIRE(market != nullptr, "Internal error, buildCrossAssetModel needs to be called after the market is built.");
    CrossAssetModelBuilder modelBuilder(
        market, analytic()->configurations().crossAssetModelData, inputs_->marketConfig("lgmcalibration"),
        inputs_->marketConfig("fxcalibration"), inputs_->marketConfig("eqcalibration"),
        inputs_->marketConfig("infcalibration"), inputs_->marketConfig("crcalibration"),
        inputs_->marketConfig("simulation"), false, continueOnCalibrationError, "",
        inputs_->salvageCorrelationMatrix() ? SalvagingAlgorithm::Spectral : SalvagingAlgorithm::None,
        "xva cam building");
    model_ = *modelBuilder.model();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildScenarioGenerator()

void buildScenarioGenerator ( bool continueOnError )

protected

Definition at line 172 of file xvaanalytic.cpp.

                                                                                  {
    if (!model_)
        buildCrossAssetModel(continueOnCalibrationError);
    ScenarioGeneratorBuilder sgb(analytic()->configurations().scenarioGeneratorData);
    QuantLib::ext::shared_ptr<ScenarioFactory> sf = QuantLib::ext::make_shared<SimpleScenarioFactory>(true);
    string config = inputs_->marketConfig("simulation");
    auto market = offsetScenario_ == nullptr ? analytic()->market() : simMarketCalibration_;
    scenarioGenerator_ = sgb.build(model_, sf, analytic()->configurations().simMarketParams, inputs_->asof(), market, config);
    QL_REQUIRE(scenarioGenerator_, "failed to build the scenario generator"); 
    samples_ = analytic()->configurations().scenarioGeneratorData->samples();
    LOG("simulation grid size " << grid_->size());
    LOG("simulation grid valuation dates " << grid_->valuationDates().size());
    LOG("simulation grid close-out dates " << grid_->closeOutDates().size());
    LOG("simulation grid front date " << io::iso_date(grid_->dates().front()));    
    LOG("simulation grid back date " << io::iso_date(grid_->dates().back()));    
 
    if (inputs_->writeScenarios()) {
        auto report = QuantLib::ext::make_shared<InMemoryReport>();
        analytic()->reports()["XVA"]["scenario"] = report;
        scenarioGenerator_ = QuantLib::ext::make_shared<ScenarioWriter>(scenarioGenerator_, report);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initCubeDepth()

void initCubeDepth ( )

protected

Definition at line 210 of file xvaanalytic.cpp.

                                    {
    if (cubeDepth_ == 0) {
        LOG("XVA: Set cube depth");
        cubeDepth_ = cubeInterpreter_->requiredNpvCubeDepth();
        LOG("XVA: Cube depth set to: " << cubeDepth_);
    }
}

Here is the caller graph for this function:

◆ initCube()

void initCube	(	QuantLib::ext::shared_ptr< NPVCube > &	cube,
		const std::set< std::string > &	ids,
		Size	cubeDepth
	)

protected

Definition at line 218 of file xvaanalytic.cpp.

                                                                                                                 {
 
    LOG("Init cube with depth " << cubeDepth);
 
    for (Size i = 0; i < grid_->valuationDates().size(); ++i)
        DLOG("initCube: grid[" << i << "]=" << io::iso_date(grid_->valuationDates()[i]));
    
    if (cubeDepth == 1)
        cube = QuantLib::ext::make_shared<SinglePrecisionInMemoryCube>(inputs_->asof(),
            ids, grid_->valuationDates(), samples_, 0.0f);
    else
        cube = QuantLib::ext::make_shared<SinglePrecisionInMemoryCubeN>(inputs_->asof(),
            ids, grid_->valuationDates(), samples_, cubeDepth, 0.0f);    
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initClassicRun()

void initClassicRun ( const QuantLib::ext::shared_ptr< Portfolio > & portfolio )

protected

Definition at line 234 of file xvaanalytic.cpp.

                                                                                      {
        
    LOG("XVA: initClassicRun");
 
    initCubeDepth();
 
    // May have been set already
    if (scenarioData_.empty()) {
        LOG("XVA: Create asd " << grid_->valuationDates().size() << " x " << samples_);
        scenarioData_.linkTo(
            QuantLib::ext::make_shared<InMemoryAggregationScenarioData>(grid_->valuationDates().size(), samples_));
        simMarket_->aggregationScenarioData() = *scenarioData_;
 
    }
 
    // We can skip the cube initialization if the mt val engine is used, since it builds its own cubes
    if (inputs_->nThreads() == 1) {
        if (portfolio->size() > 0)
            initCube(cube_, portfolio->ids(), cubeDepth_);
        // not required by any calculators in ore at the moment
        nettingSetCube_ = nullptr;
        // Init counterparty cube for the storage of survival probabilities
        if (inputs_->storeSurvivalProbabilities()) {
            // Use full list of counterparties, not just those in the sub-portflio
            auto counterparties = inputs_->portfolio()->counterparties();
            counterparties.insert(inputs_->dvaName());
            initCube(cptyCube_, counterparties, 1);
        } else {
            cptyCube_ = nullptr;
        }
    }
 
    LOG("XVA: initClassicRun completed");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildClassicCube()

void buildClassicCube ( const QuantLib::ext::shared_ptr< Portfolio > & portfolio )

protected

Definition at line 308 of file xvaanalytic.cpp.

                                                                                        {
 
    LOG("XVA::buildCube"); 
    
    // set up valuation calculator factory
    auto calculators = [this]() {
        vector<QuantLib::ext::shared_ptr<ValuationCalculator>> calculators;
        if (analytic()->configurations().scenarioGeneratorData->withCloseOutLag()) {
            QuantLib::ext::shared_ptr<NPVCalculator> npvCalc =
                QuantLib::ext::make_shared<NPVCalculator>(inputs_->exposureBaseCurrency());
            calculators.push_back(QuantLib::ext::make_shared<MPORCalculator>(npvCalc, cubeInterpreter_->defaultDateNpvIndex(),
                                                                     cubeInterpreter_->closeOutDateNpvIndex()));
        } else
            calculators.push_back(QuantLib::ext::make_shared<NPVCalculator>(inputs_->exposureBaseCurrency()));
        if (inputs_->storeFlows())
            calculators.push_back(QuantLib::ext::make_shared<CashflowCalculator>(
                inputs_->exposureBaseCurrency(), inputs_->asof(), grid_, cubeInterpreter_->mporFlowsIndex()));
        if(inputs_->storeCreditStateNPVs() > 0) {
            calculators.push_back(QuantLib::ext::make_shared<MultiStateNPVCalculator>(inputs_->exposureBaseCurrency(),
                                                                              cubeInterpreter_->creditStateNPVsIndex(),
                                                                              inputs_->storeCreditStateNPVs()));
        }
        return calculators;
    };
 
    // set up cpty calculator factory
 
    auto cptyCalculators = [this]() {
        vector<QuantLib::ext::shared_ptr<CounterpartyCalculator>> cptyCalculators;
        if (inputs_->storeSurvivalProbabilities()) {
            string configuration = inputs_->marketConfig("simulation");
            cptyCalculators.push_back(QuantLib::ext::make_shared<SurvivalProbabilityCalculator>(configuration));
        }
        return cptyCalculators;
    };
 
    // log message
 
    ostringstream o;
    o << "XVA: Build Cube " << portfolio->size() << " x " << grid_->valuationDates().size() << " x " << samples_;
    CONSOLEW(o.str());
    LOG(o.str());
 
    // set up progress indicators
 
    auto progressBar = QuantLib::ext::make_shared<SimpleProgressBar>(o.str(), ConsoleLog::instance().width(), ConsoleLog::instance().progressBarWidth());
    auto progressLog = QuantLib::ext::make_shared<ProgressLog>("XVA: Building cube", 100, oreSeverity::notice);
 
    if(inputs_->nThreads() == 1) {
 
        // single-threaded engine run
 
        ValuationEngine engine(inputs_->asof(), grid_, simMarket_);
        engine.registerProgressIndicator(progressBar);
        engine.registerProgressIndicator(progressLog);
        engine.buildCube(portfolio, cube_, calculators(), analytic()->configurations().scenarioGeneratorData->withMporStickyDate(),
                         nettingSetCube_, cptyCube_, cptyCalculators());
    } else {
 
        // multi-threaded engine run
 
        /* TODO we assume no netting output cube is needed. Currently there are no valuation calculators in ore that require this cube. */
 
        auto cubeFactory = [this](const QuantLib::Date& asof, const std::set<std::string>& ids,
                                  const std::vector<QuantLib::Date>& dates,
                                  const Size samples) -> QuantLib::ext::shared_ptr<NPVCube> {
            if (cubeDepth_ == 1)
                return QuantLib::ext::make_shared<SinglePrecisionInMemoryCube>(asof, ids, dates, samples, 0.0f);
            else
                return QuantLib::ext::make_shared<SinglePrecisionInMemoryCubeN>(asof, ids, dates, samples,
                                                                                        cubeDepth_, 0.0f);
        };
 
        std::function<QuantLib::ext::shared_ptr<NPVCube>(const QuantLib::Date&, const std::set<std::string>&,
                                                                 const std::vector<QuantLib::Date>&,
                                                                 const QuantLib::Size)>
            cptyCubeFactory;
        if (inputs_->storeSurvivalProbabilities()) {
            cptyCubeFactory = [](const QuantLib::Date& asof, const std::set<std::string>& ids,
                                 const std::vector<QuantLib::Date>& dates,
                                 const Size samples) -> QuantLib::ext::shared_ptr<NPVCube> {
                return QuantLib::ext::make_shared<SinglePrecisionInMemoryCube>(asof, ids, dates, samples, 0.0f);
            };
        } else {
            cptyCubeFactory = [](const QuantLib::Date& asof, const std::set<std::string>& ids,
                                 const std::vector<QuantLib::Date>& dates,
                                 const Size samples) -> QuantLib::ext::shared_ptr<NPVCube> { return nullptr; };
        }
 
        MultiThreadedValuationEngine engine(
            inputs_->nThreads(), inputs_->asof(), grid_, samples_, analytic()->loader(), scenarioGenerator_,
            inputs_->simulationPricingEngine(), inputs_->curveConfigs().get(),
            analytic()->configurations().todaysMarketParams, inputs_->marketConfig("simulation"),
            analytic()->configurations().simMarketParams, false, false, QuantLib::ext::make_shared<ScenarioFilter>(),
            inputs_->refDataManager(), *inputs_->iborFallbackConfig(), true, false, false, cubeFactory, {},
            cptyCubeFactory, "xva-simulation", offsetScenario_);
 
        engine.setAggregationScenarioData(*scenarioData_);
        engine.registerProgressIndicator(progressBar);
        engine.registerProgressIndicator(progressLog);
 
        engine.buildCube(portfolio, calculators, cptyCalculators,
                         analytic()->configurations().scenarioGeneratorData->withMporStickyDate());
 
        cube_ = QuantLib::ext::make_shared<JointNPVCube>(engine.outputCubes(), portfolio->ids());
 
        if (inputs_->storeSurvivalProbabilities())
            cptyCube_ = QuantLib::ext::make_shared<JointNPVCube>(
                engine.outputCptyCubes(), portfolio->counterparties(), false,
                [](Real a, Real x) { return std::max(a, x); }, 0.0);
    }
 
    CONSOLE("OK");
 
    LOG("XVA::buildCube done");
 
    Settings::instance().evaluationDate() = inputs_->asof();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ classicRun()

QuantLib::ext::shared_ptr< Portfolio > classicRun ( const QuantLib::ext::shared_ptr< Portfolio > & portfolio )

protected

Definition at line 270 of file xvaanalytic.cpp.

                                                                                                              {
    LOG("XVA: classicRun");
 
 
    Size n = portfolio->size();
    // Create a new empty portfolio, fill it and link it to the simulation market
    // We don't use Analytic::buildPortfolio() here because we are possibly dealing with a sub-portfolio only.
    LOG("XVA: Build classic portfolio of size " << n << " linked to the simulation market");
    const string msg = "XVA: Build Portfolio";
    CONSOLEW(msg);
    ProgressMessage(msg, 0, 1).log();
    classicPortfolio_ = QuantLib::ext::make_shared<Portfolio>(inputs_->buildFailedTrades());
    portfolio->reset();
    for (const auto& [tradeId, trade] : portfolio->trades())
        classicPortfolio_->add(trade);    
    QL_REQUIRE(analytic()->market(), "today's market not set");
    QuantLib::ext::shared_ptr<EngineFactory> factory = engineFactory();
    classicPortfolio_->build(factory, "analytic/" + label());
    Date maturityDate = inputs_->asof();
    if (inputs_->portfolioFilterDate() != Null<Date>())
        maturityDate = inputs_->portfolioFilterDate();
    LOG("Filter trades that expire before " << maturityDate);
    classicPortfolio_->removeMatured(maturityDate);
    CONSOLE("OK");
    ProgressMessage(msg, 1, 1).log();
 
    // Allocate cubes for the sub-portfolio we are processing here
    initClassicRun(classicPortfolio_);
 
    // This is where the valuation work is done
    buildClassicCube(classicPortfolio_);
 
    LOG("XVA: classicRun completed");
 
    return classicPortfolio_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ amcEngineFactory()

QuantLib::ext::shared_ptr< EngineFactory > amcEngineFactory	(	const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &	cam,
		const std::vector< Date > &	grid
	)

protected

Definition at line 428 of file xvaanalytic.cpp.

                                                                                            {
    LOG("XvaAnalytic::engineFactory() called");
    QuantLib::ext::shared_ptr<EngineData> edCopy = QuantLib::ext::make_shared<EngineData>(*inputs_->amcPricingEngine());
    edCopy->globalParameters()["GenerateAdditionalResults"] = "false";
    edCopy->globalParameters()["RunType"] = "NPV";
    map<MarketContext, string> configurations;
    configurations[MarketContext::irCalibration] = inputs_->marketConfig("lgmcalibration");    
    configurations[MarketContext::fxCalibration] = inputs_->marketConfig("fxcalibration");
    configurations[MarketContext::pricing] = inputs_->marketConfig("pricing");
    ext::shared_ptr<ore::data::Market> market =
        offsetScenario_ == nullptr ? analytic()->market() : offsetSimMarket_;
    auto factory = QuantLib::ext::make_shared<EngineFactory>(
        edCopy, market, configurations, inputs_->refDataManager(), *inputs_->iborFallbackConfig(),
        EngineBuilderFactory::instance().generateAmcEngineBuilders(cam, grid), true);
    return factory;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildAmcPortfolio()

void buildAmcPortfolio ( )

protected

Definition at line 446 of file xvaanalytic.cpp.

                                        {
    LOG("XVA: buildAmcPortfolio");
    const string msg = "XVA: Build AMC portfolio";
    CONSOLEW(msg);
    ProgressMessage(msg, 0, 1).log();
 
    LOG("buildAmcPortfolio: Check sim dates");
    std::vector<Date> simDates =
        analytic()->configurations().scenarioGeneratorData->withCloseOutLag() && !analytic()->configurations().scenarioGeneratorData->withMporStickyDate() ?
        analytic()->configurations().scenarioGeneratorData->getGrid()->dates() : analytic()->configurations().scenarioGeneratorData->getGrid()->valuationDates();
    
    LOG("buildAmcPortfolio: Register additional engine builders");
    auto factory = amcEngineFactory(model_, simDates);
 
    LOG("buildAmcPortfolio: Load Portfolio");
    QuantLib::ext::shared_ptr<Portfolio> portfolio = inputs_->portfolio();
 
    LOG("Build Portfolio with AMC Engine factory and select amc-enabled trades")
    amcPortfolio_ = QuantLib::ext::make_shared<Portfolio>();
    for (auto const& [tradeId, trade] : portfolio->trades()) {
        if (inputs_->amcTradeTypes().find(trade->tradeType()) != inputs_->amcTradeTypes().end()) {
            try {
                trade->reset();
                trade->build(factory);
                amcPortfolio_->add(trade);
                DLOG("trade " << tradeId << " is added to amc portfolio");
            } catch (const std::exception& e) {
                StructuredTradeErrorMessage(trade, "Error building trade for AMC simulation", e.what()).log();
            }
        }
    }
    LOG("AMC portfolio built, size is " << amcPortfolio_->size());
 
    CONSOLE("OK");
    ProgressMessage(msg, 1, 1).log();
 
    LOG("XVA: buildAmcPortfolio completed");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ amcRun()

void amcRun ( bool doClassicRun )

protected

Definition at line 485 of file xvaanalytic.cpp.

                                              {
 
    LOG("XVA: amcRun");
 
    if (scenarioData_.empty()) {
        LOG("XVA: Create asd " << grid_->valuationDates().size() << " x " << samples_);
        scenarioData_.linkTo(
            QuantLib::ext::make_shared<InMemoryAggregationScenarioData>(grid_->valuationDates().size(), samples_));
        simMarket_->aggregationScenarioData() = *scenarioData_;
    }
 
    initCubeDepth();
 
    std::string message = "XVA: Build AMC Cube " + std::to_string(amcPortfolio_->size()) + " x " +
                          std::to_string(grid_->valuationDates().size()) + " x " + std::to_string(samples_) + "... ";
    auto progressBar = QuantLib::ext::make_shared<SimpleProgressBar>(message, ConsoleLog::instance().width(), ConsoleLog::instance().progressBarWidth());
    auto progressLog = QuantLib::ext::make_shared<ProgressLog>("XVA: Building AMC Cube...", 100, oreSeverity::notice);
 
    if (inputs_->nThreads() == 1) {
        initCube(amcCube_, amcPortfolio_->ids(), cubeDepth_);
        ext::shared_ptr<ore::data::Market> market = offsetScenario_ == nullptr ? analytic()->market() : offsetSimMarket_;
 
        AMCValuationEngine amcEngine(model_, inputs_->scenarioGeneratorData(), market,
                                     inputs_->exposureSimMarketParams()->additionalScenarioDataIndices(),
                                     inputs_->exposureSimMarketParams()->additionalScenarioDataCcys(),
                                     inputs_->exposureSimMarketParams()->additionalScenarioDataNumberOfCreditStates());
        amcEngine.registerProgressIndicator(progressBar);
        amcEngine.registerProgressIndicator(progressLog);
        if (!scenarioData_.empty())
            amcEngine.aggregationScenarioData() = *scenarioData_;
        amcEngine.buildCube(amcPortfolio_, amcCube_);
    } else {
        auto cubeFactory = [this](const QuantLib::Date& asof, const std::set<std::string>& ids,
                                  const std::vector<QuantLib::Date>& dates,
                                  const Size samples) -> QuantLib::ext::shared_ptr<NPVCube> {
            if (cubeDepth_ == 1)
                return QuantLib::ext::make_shared<SinglePrecisionInMemoryCube>(asof, ids, dates, samples, 0.0f);
            else
                return QuantLib::ext::make_shared<SinglePrecisionInMemoryCubeN>(asof, ids, dates, samples,
                                                                                        cubeDepth_, 0.0f);
        };
 
        auto simMarketParams =
            offsetScenario_ == nullptr ? analytic()->configurations().simMarketParams : offsetSimMarketParams_;
 
        AMCValuationEngine amcEngine(
            inputs_->nThreads(), inputs_->asof(), samples_, analytic()->loader(), inputs_->scenarioGeneratorData(),
            inputs_->exposureSimMarketParams()->additionalScenarioDataIndices(),
            inputs_->exposureSimMarketParams()->additionalScenarioDataCcys(),
            inputs_->exposureSimMarketParams()->additionalScenarioDataNumberOfCreditStates(),
            inputs_->crossAssetModelData(), inputs_->amcPricingEngine(), inputs_->curveConfigs().get(),
            analytic()->configurations().todaysMarketParams, inputs_->marketConfig("lgmcalibration"),
            inputs_->marketConfig("fxcalibration"), inputs_->marketConfig("eqcalibration"),
            inputs_->marketConfig("infcalibration"), inputs_->marketConfig("crcalibration"),
            inputs_->marketConfig("simulation"), inputs_->refDataManager(), *inputs_->iborFallbackConfig(), true,
            cubeFactory, offsetScenario_, simMarketParams);
 
        amcEngine.registerProgressIndicator(progressBar);
        amcEngine.registerProgressIndicator(progressLog);
        if (!scenarioData_.empty())
            amcEngine.aggregationScenarioData() = *scenarioData_;
        amcEngine.buildCube(amcPortfolio_);
        amcCube_ = QuantLib::ext::make_shared<JointNPVCube>(amcEngine.outputCubes());
    }
 
    CONSOLE("OK");
 
    LOG("XVA: amcRun completed");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ runPostProcessor()

void runPostProcessor ( )

protected

Definition at line 555 of file xvaanalytic.cpp.

                                       {    
    QuantLib::ext::shared_ptr<NettingSetManager> netting = inputs_->nettingSetManager();
    QuantLib::ext::shared_ptr<CollateralBalances> balances = inputs_->collateralBalances();
    map<string, bool> analytics;
    analytics["exerciseNextBreak"] = inputs_->exerciseNextBreak();
    analytics["cva"] = inputs_->cvaAnalytic();
    analytics["dva"] = inputs_->dvaAnalytic();
    analytics["fva"] = inputs_->fvaAnalytic();
    analytics["colva"] = inputs_->colvaAnalytic();
    analytics["collateralFloor"] = inputs_->collateralFloorAnalytic();
    analytics["mva"] = inputs_->mvaAnalytic();
    analytics["kva"] = inputs_->kvaAnalytic();
    analytics["dim"] = inputs_->dimAnalytic();
    analytics["dynamicCredit"] = inputs_->dynamicCredit();
    analytics["cvaSensi"] = inputs_->cvaSensi();
    analytics["flipViewXVA"] = inputs_->flipViewXVA();
    analytics["creditMigration"] = inputs_->creditMigrationAnalytic();
 
    string baseCurrency = inputs_->xvaBaseCurrency();
    string calculationType = inputs_->collateralCalculationType();
    string allocationMethod = inputs_->exposureAllocationMethod();
    Real marginalAllocationLimit = inputs_->marginalAllocationLimit();
    Real quantile = inputs_->pfeQuantile();
    string dvaName = inputs_->dvaName();
    string fvaLendingCurve = inputs_->fvaLendingCurve();
    string fvaBorrowingCurve = inputs_->fvaBorrowingCurve();
 
    Real dimQuantile = inputs_->dimQuantile();
    Size dimHorizonCalendarDays = inputs_->dimHorizonCalendarDays();
    Size dimRegressionOrder = inputs_->dimRegressionOrder();
    vector<string> dimRegressors = inputs_->dimRegressors();
    Size dimLocalRegressionEvaluations = inputs_->dimLocalRegressionEvaluations();
    Real dimLocalRegressionBandwidth = inputs_->dimLocalRegressionBandwidth();
 
    Real kvaCapitalDiscountRate = inputs_->kvaCapitalDiscountRate();
    Real kvaAlpha = inputs_->kvaAlpha();
    Real kvaRegAdjustment = inputs_->kvaRegAdjustment();
    Real kvaCapitalHurdle = inputs_->kvaCapitalHurdle();
    Real kvaOurPdFloor = inputs_->kvaOurPdFloor();
    Real kvaTheirPdFloor = inputs_->kvaTheirPdFloor();
    Real kvaOurCvaRiskWeight = inputs_->kvaOurCvaRiskWeight();
    Real kvaTheirCvaRiskWeight = inputs_->kvaTheirCvaRiskWeight();
 
    string marketConfiguration = inputs_->marketConfig("simulation");
 
    bool fullInitialCollateralisation = inputs_->fullInitialCollateralisation();
 
    checkConfigurations(analytic()->portfolio());
 
    if (!dimCalculator_ && (analytics["mva"] || analytics["dim"])) {
        if (inputs_->dimModel() == "Regression") {
            LOG("dim calculator not set, create RegressionDynamicInitialMarginCalculator");
            std::map<std::string, Real> currentIM;
            if (inputs_->collateralBalances()) {
                for (auto const& [n, b] : inputs_->collateralBalances()->collateralBalances()) {
                    currentIM[n.nettingSetId()] =
                        b->initialMargin() * (b->currency() == baseCurrency
                                                  ? 1.0
                                                  : analytic()
                                                        ->market()
                                                        ->fxRate(b->currency() + baseCurrency, marketConfiguration)
                                                        ->value());
                }
            }
            dimCalculator_ = QuantLib::ext::make_shared<RegressionDynamicInitialMarginCalculator>(
                inputs_, analytic()->portfolio(), cube_, cubeInterpreter_, *scenarioData_, dimQuantile,
                dimHorizonCalendarDays, dimRegressionOrder, dimRegressors, dimLocalRegressionEvaluations,
                dimLocalRegressionBandwidth, currentIM);
        } else {
            LOG("dim calculator not set, create FlatDynamicInitialMarginCalculator");
            dimCalculator_ = QuantLib::ext::make_shared<FlatDynamicInitialMarginCalculator>(
                inputs_, analytic()->portfolio(), cube_, cubeInterpreter_, *scenarioData_);
        }
    }
 
    std::vector<Period> cvaSensiGrid = inputs_->cvaSensiGrid();
    Real cvaSensiShiftSize = inputs_->cvaSensiShiftSize();
 
    string flipViewBorrowingCurvePostfix = inputs_->flipViewBorrowingCurvePostfix();
    string flipViewLendingCurvePostfix = inputs_->flipViewLendingCurvePostfix();
 
    LOG("baseCurrency " << baseCurrency);
 
    auto market = offsetScenario_ == nullptr ? analytic()->market() : offsetSimMarket_;
 
    postProcess_ = QuantLib::ext::make_shared<PostProcess>(
        analytic()->portfolio(), netting, balances, market, marketConfiguration, cube_, *scenarioData_, analytics,
        baseCurrency, allocationMethod, marginalAllocationLimit, quantile, calculationType, dvaName, fvaBorrowingCurve,
        fvaLendingCurve, dimCalculator_, cubeInterpreter_, fullInitialCollateralisation, cvaSensiGrid,
        cvaSensiShiftSize, kvaCapitalDiscountRate, kvaAlpha, kvaRegAdjustment, kvaCapitalHurdle, kvaOurPdFloor,
        kvaTheirPdFloor, kvaOurCvaRiskWeight, kvaTheirCvaRiskWeight, cptyCube_, flipViewBorrowingCurvePostfix,
        flipViewLendingCurvePostfix, inputs_->creditSimulationParameters(), inputs_->creditMigrationDistributionGrid(),
        inputs_->creditMigrationTimeSteps(), creditStateCorrelationMatrix(),
        analytic()->configurations().scenarioGeneratorData->withMporStickyDate(), inputs_->mporCashFlowMode());
    LOG("post done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ creditStateCorrelationMatrix()

Matrix creditStateCorrelationMatrix ( ) const

protected

Definition at line 965 of file xvaanalytic.cpp.

                                                           {
 
    CorrelationMatrixBuilder cmb;
    for (auto const& [pair, value] : analytic()->configurations().crossAssetModelData->correlations()) {
        cmb.addCorrelation(pair.first, pair.second, value);
    }
 
    CorrelationMatrixBuilder::ProcessInfo processInfo;
    processInfo[CrossAssetModel::AssetType::CrState] = {
        {"CrState", analytic()->configurations().simMarketParams->numberOfCreditStates()}};
 
    return cmb.correlationMatrix(processInfo);
}

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"

staticconstexpr

Definition at line 32 of file xvaanalytic.hpp.

◆ simMarket_

QuantLib::ext::shared_ptr<ScenarioSimMarket> simMarket_

protected

Definition at line 71 of file xvaanalytic.hpp.

◆ simMarketCalibration_

QuantLib::ext::shared_ptr<ScenarioSimMarket> simMarketCalibration_

protected

Definition at line 72 of file xvaanalytic.hpp.

◆ offsetSimMarket_

QuantLib::ext::shared_ptr<ScenarioSimMarket> offsetSimMarket_

protected

Definition at line 73 of file xvaanalytic.hpp.

◆ engineFactory_

QuantLib::ext::shared_ptr<EngineFactory> engineFactory_

protected

Definition at line 74 of file xvaanalytic.hpp.

◆ model_

QuantLib::ext::shared_ptr<CrossAssetModel> model_

protected

Definition at line 75 of file xvaanalytic.hpp.

◆ scenarioGenerator_

QuantLib::ext::shared_ptr<ScenarioGenerator> scenarioGenerator_

protected

Definition at line 76 of file xvaanalytic.hpp.

◆ amcPortfolio_

QuantLib::ext::shared_ptr<Portfolio> amcPortfolio_

protected

Definition at line 77 of file xvaanalytic.hpp.

◆ classicPortfolio_

QuantLib::ext::shared_ptr<Portfolio> classicPortfolio_

protected

Definition at line 77 of file xvaanalytic.hpp.

◆ cube_

QuantLib::ext::shared_ptr<NPVCube> cube_

protected

Definition at line 78 of file xvaanalytic.hpp.

◆ nettingSetCube_

QuantLib::ext::shared_ptr<NPVCube> nettingSetCube_

protected

Definition at line 78 of file xvaanalytic.hpp.

◆ cptyCube_

QuantLib::ext::shared_ptr<NPVCube> cptyCube_

protected

Definition at line 78 of file xvaanalytic.hpp.

◆ amcCube_

QuantLib::ext::shared_ptr<NPVCube> amcCube_

protected

Definition at line 78 of file xvaanalytic.hpp.

◆ scenarioData_

QuantLib::RelinkableHandle<AggregationScenarioData> scenarioData_

protected

Definition at line 79 of file xvaanalytic.hpp.

◆ cubeInterpreter_

QuantLib::ext::shared_ptr<CubeInterpretation> cubeInterpreter_

protected

Definition at line 80 of file xvaanalytic.hpp.

◆ dimCalculator_

QuantLib::ext::shared_ptr<DynamicInitialMarginCalculator> dimCalculator_

protected

Definition at line 81 of file xvaanalytic.hpp.

◆ postProcess_

QuantLib::ext::shared_ptr<PostProcess> postProcess_

protected

Definition at line 82 of file xvaanalytic.hpp.

◆ offsetScenario_

QuantLib::ext::shared_ptr<Scenario> offsetScenario_

protected

Definition at line 83 of file xvaanalytic.hpp.

◆ offsetSimMarketParams_

QuantLib::ext::shared_ptr<ScenarioSimMarketParameters> offsetSimMarketParams_

protected

Definition at line 84 of file xvaanalytic.hpp.

◆ cubeDepth_

Size cubeDepth_ = 0

protected

Definition at line 85 of file xvaanalytic.hpp.

◆ grid_

QuantLib::ext::shared_ptr<DateGrid> grid_

protected

Definition at line 86 of file xvaanalytic.hpp.

◆ samples_

Size samples_ = 0

protected

Definition at line 87 of file xvaanalytic.hpp.

◆ runSimulation_

bool runSimulation_ = false

protected

Definition at line 89 of file xvaanalytic.hpp.

◆ runXva_

bool runXva_ = false

protected

Definition at line 90 of file xvaanalytic.hpp.

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ XvaAnalyticImpl()

Member Function Documentation

◆ runAnalytic()

◆ setUpConfigurations()

◆ checkConfigurations()

◆ engineFactory()

◆ buildScenarioSimMarket()

◆ buildCrossAssetModel()

◆ buildScenarioGenerator()

◆ initCubeDepth()

◆ initCube()

◆ initClassicRun()

◆ buildClassicCube()

◆ classicRun()

◆ amcEngineFactory()

◆ buildAmcPortfolio()

◆ amcRun()

◆ runPostProcessor()

◆ creditStateCorrelationMatrix()

Member Data Documentation

◆ LABEL

◆ simMarket_

◆ simMarketCalibration_

◆ offsetSimMarket_

◆ engineFactory_

◆ model_

◆ scenarioGenerator_

◆ amcPortfolio_

◆ classicPortfolio_

◆ cube_

◆ nettingSetCube_

◆ cptyCube_

◆ amcCube_

◆ scenarioData_

◆ cubeInterpreter_

◆ dimCalculator_

◆ postProcess_

◆ offsetScenario_

◆ offsetSimMarketParams_

◆ cubeDepth_

◆ grid_

◆ samples_

◆ runSimulation_

◆ runXva_