Exposure Aggregation and XVA Calculation. More...

#include <orea/aggregation/postprocess.hpp>

Collaboration diagram for PostProcess:

Public Member Functions
	PostProcess (const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< NettingSetManager > &nettingSetManager, const QuantLib::ext::shared_ptr< CollateralBalances > &collateralBalances, const QuantLib::ext::shared_ptr< Market > &market, const std::string &configuration, const QuantLib::ext::shared_ptr< NPVCube > &cube, const QuantLib::ext::shared_ptr< AggregationScenarioData > &scenarioData, const map< string, bool > &analytics, const string &baseCurrency, const string &allocationMethod, Real cvaMarginalAllocationLimit, Real quantile=0.95, const string &calculationType="Symmetric", const string &dvaName="", const string &fvaBorrowingCurve="", const string &fvaLendingCurve="", const QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator > &dimCalculator=QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator >(), const QuantLib::ext::shared_ptr< CubeInterpretation > &cubeInterpretation=QuantLib::ext::shared_ptr< CubeInterpretation >(), bool fullInitialCollateralisation=false, vector< Period > cvaSpreadSensiGrid={6 Months, 1 Years, 3 Years, 5 Years, 10 *Years}, Real cvaSpreadSensiShiftSize=0.0001, Real kvaCapitalDiscountRate=0.10, Real kvaAlpha=1.4, Real kvaRegAdjustment=12.5, Real kvaCapitalHurdle=0.012, Real kvaOurPdFloor=0.03, Real kvaTheirPdFloor=0.03, Real kvaOurCvaRiskWeight=0.05, Real kvaTheirCvaRiskWeight=0.05, const QuantLib::ext::shared_ptr< NPVCube > &cptyCube_=nullptr, const string &flipViewBorrowingCurvePostfix="_BORROW", const string &flipViewLendingCurvePostfix="_LEND", const QuantLib::ext::shared_ptr< CreditSimulationParameters > &creditSimulationParameters=nullptr, const std::vector< Real > &creditMigrationDistributionGrid={}, const std::vector< Size > &creditMigrationTimeSteps={}, const Matrix &creditStateCorrelationMatrix=Matrix(), bool withMporStickyDate=false, const MporCashFlowMode mporCashFlowMode=MporCashFlowMode::Unspecified)
	Constructor. More...

void	setDimCalculator (QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator > dimCalculator)

const vector< Real > &	spreadSensitivityTimes ()

const vector< Period > &	spreadSensitivityGrid ()

const std::map< string, Size >	tradeIds ()
	Return list of Trade IDs in the portfolio. More...

const std::map< string, Size >	nettingSetIds ()
	Return list of netting set IDs in the portfolio. More...

const map< string, string > &	counterpartyId ()
	Return the map of counterparty Ids. More...

const vector< Real > &	tradeEPE (const string &tradeId)
	Return trade level Expected Positive Exposure evolution. More...

const vector< Real > &	tradeENE (const string &tradeId)
	Return trade level Expected Negative Exposure evolution. More...

const vector< Real > &	tradeEE_B (const string &tradeId)
	Return trade level Basel Expected Exposure evolution. More...

const Real &	tradeEPE_B (const string &tradeId)
	Return trade level Basel Expected Positive Exposure evolution. More...

const vector< Real > &	tradeEEE_B (const string &tradeId)
	Return trade level Effective Expected Exposure evolution. More...

const Real &	tradeEEPE_B (const string &tradeId)
	Return trade level Effective Expected Positive Exposure evolution. More...

const vector< Real > &	tradePFE (const string &tradeId)
	Return trade level Potential Future Exposure evolution. More...

const vector< Real > &	netEPE (const string &nettingSetId)
	Return Netting Set Expected Positive Exposure evolution. More...

const vector< Real > &	netENE (const string &nettingSetId)
	Return Netting Set Expected Negative Exposure evolution. More...

const vector< Real > &	netEE_B (const string &nettingSetId)
	Return Netting Set Basel Expected Exposure evolution. More...

const Real &	netEPE_B (const string &nettingSetId)
	Return Netting Set Basel Expected Positive Exposure evolution. More...

const vector< Real > &	netEEE_B (const string &nettingSetId)
	Return Netting Set Effective Expected Exposure evolution. More...

const Real &	netEEPE_B (const string &nettingSetId)
	Return Netting Set Effective Expected Positive Exposure evolution. More...

const vector< Real > &	netPFE (const string &nettingSetId)
	Return Netting Set Potential Future Exposure evolution. More...

const vector< Real > &	expectedCollateral (const string &nettingSetId)
	Return the netting set's expected collateral evolution. More...

const vector< Real > &	colvaIncrements (const string &nettingSetId)
	Return the netting set's expected COLVA increments through time. More...

const vector< Real > &	collateralFloorIncrements (const string &nettingSetId)
	Return the netting set's expected Collateral Floor increments through time. More...

const vector< Real > &	allocatedTradeEPE (const string &tradeId)
	Return the trade EPE, allocated down from the netting set level. More...

const vector< Real > &	allocatedTradeENE (const string &tradeId)
	Return trade ENE, allocated down from the netting set level. More...

vector< Real >	netCvaHazardRateSensitivity (const string &nettingSetId)
	Return Netting Set CVA Hazard Rate Sensitivity vector. More...

vector< Real >	netCvaSpreadSensitivity (const string &nettingSetId)
	Return Netting Set CVA Spread Sensitivity vector. More...

const std::map< std::string, std::vector< QuantLib::Real > > &	netCvaSpreadSensitivity () const
	Return Netting Set CVA Spread Sensitivity vector. More...

Real	tradeCVA (const string &tradeId)
	Return trade (stand-alone) CVA. More...

Real	tradeDVA (const string &tradeId)
	Return trade (stand-alone) DVA. More...

Real	tradeMVA (const string &tradeId)
	Return trade (stand-alone) MVA. More...

Real	tradeFBA (const string &tradeId)
	Return trade (stand-alone) FBA (Funding Benefit Adjustment) More...

Real	tradeFCA (const string &tradeId)
	Return trade (stand-alone) FCA (Funding Cost Adjustment) More...

Real	tradeFBA_exOwnSP (const string &tradeId)
	Return trade (stand-alone) FBA (Funding Benefit Adjustment) excluding own survival probability. More...

Real	tradeFCA_exOwnSP (const string &tradeId)
	Return trade (stand-alone) FCA (Funding Cost Adjustment) excluding own survival probability. More...

Real	tradeFBA_exAllSP (const string &tradeId)
	Return trade (stand-alone) FBA (Funding Benefit Adjustment) excluding both survival probabilities. More...

Real	tradeFCA_exAllSP (const string &tradeId)
	Return trade (stand-alone) FCA (Funding Cost Adjustment) excluding both survival probabilities. More...

Real	allocatedTradeCVA (const string &tradeId)
	Return allocated trade CVA (trade CVAs add up to netting set CVA) More...

Real	allocatedTradeDVA (const string &tradeId)
	Return allocated trade DVA (trade DVAs add up to netting set DVA) More...

Real	nettingSetCVA (const string &nettingSetId)
	Return netting set CVA. More...

Real	nettingSetDVA (const string &nettingSetId)
	Return netting set DVA. More...

Real	nettingSetMVA (const string &nettingSetId)
	Return netting set MVA. More...

Real	nettingSetFBA (const string &nettingSetId)
	Return netting set FBA. More...

Real	nettingSetFCA (const string &nettingSetId)
	Return netting set FCA. More...

Real	nettingSetOurKVACCR (const string &nettingSetId)
	Return netting set KVA-CCR. More...

Real	nettingSetTheirKVACCR (const string &nettingSetId)
	Return netting set KVA-CCR from counterparty perspective. More...

Real	nettingSetOurKVACVA (const string &nettingSetId)
	Return netting set KVA-CVA. More...

Real	nettingSetTheirKVACVA (const string &nettingSetId)
	Return netting set KVA-CVA from counterparty perspective. More...

Real	nettingSetFBA_exOwnSP (const string &nettingSetId)
	Return netting set FBA excluding own survival probability. More...

Real	nettingSetFCA_exOwnSP (const string &nettingSetId)
	Return netting set FCA excluding own survival probability. More...

Real	nettingSetFBA_exAllSP (const string &nettingSetId)
	Return netting set FBA excluding both survival probabilities. More...

Real	nettingSetFCA_exAllSP (const string &nettingSetId)
	Return netting set FCA excluding both survival probabilities. More...

Real	nettingSetCOLVA (const string &nettingSetId)
	Return netting set COLVA. More...

Real	nettingSetCollateralFloor (const string &nettingSetId)
	Return netting set Collateral Floor value. More...

const QuantLib::ext::shared_ptr< NPVCube > &	cube ()
	Inspector for the input NPV cube (by trade, time, scenario) More...

const QuantLib::ext::shared_ptr< NPVCube > &	cptyCube ()
	Inspector for the input Cpty cube (by name, time, scenario) More...

const QuantLib::ext::shared_ptr< NPVCube > &	netCube ()
	Return the for the input NPV cube after netting and collateral (by netting set, time, scenario) More...

void	exportDimEvolution (ore::data::Report &dimEvolutionReport)
	Return the dynamic initial margin cube (regression approach) More...

void	exportDimRegression (const std::string &nettingSet, const std::vector< Size > &timeSteps, const std::vector< QuantLib::ext::shared_ptr< ore::data::Report > > &dimRegReports)
	Write DIM as a function of sample netting set NPV for a given time step. More...

QuantLib::Real	cvaSpreadSensiShiftSize ()
	get the cvaSpreadSensiShiftSize More...

const std::vector< Real > &	creditMigrationUpperBucketBounds () const
	get the credit migration pnl distributions for each time step More...

const std::vector< std::vector< Real > > &	creditMigrationCdf () const

const std::vector< std::vector< Real > > &	creditMigrationPdf () const

Protected Member Functions
QuantLib::ext::shared_ptr< vector< QuantLib::ext::shared_ptr< CollateralAccount > > >	collateralPaths (const string &nettingSetId, const QuantLib::ext::shared_ptr< NettingSetManager > &nettingSetManager, const QuantLib::ext::shared_ptr< Market > &market, const std::string &configuration, const QuantLib::ext::shared_ptr< AggregationScenarioData > &scenarioData, Size dates, Size samples, const vector< vector< Real > > &nettingSetValue, Real nettingSetValueToday, const Date &nettingSetMaturity)
	Helper function to return the collateral account evolution for a given netting set. More...

void	updateNettingSetKVA ()

void	updateNettingSetCvaSensitivity ()

Protected Attributes
QuantLib::ext::shared_ptr< Portfolio >	portfolio_

QuantLib::ext::shared_ptr< NettingSetManager >	nettingSetManager_

QuantLib::ext::shared_ptr< CollateralBalances >	collateralBalances_

QuantLib::ext::shared_ptr< Market >	market_

const std::string	configuration_

QuantLib::ext::shared_ptr< NPVCube >	cube_

QuantLib::ext::shared_ptr< NPVCube >	cptyCube_

QuantLib::ext::shared_ptr< AggregationScenarioData >	scenarioData_

map< string, bool >	analytics_

map< string, vector< Real > >	tradeEPE_

map< string, vector< Real > >	tradeENE_

map< string, vector< Real > >	allocatedTradeEPE_

map< string, vector< Real > >	allocatedTradeENE_

map< string, vector< Real > >	netEPE_

map< string, vector< Real > >	netENE_

map< string, Real >	ourNettingSetKVACCR_

map< string, Real >	theirNettingSetKVACCR_

map< string, Real >	ourNettingSetKVACVA_

map< string, Real >	theirNettingSetKVACVA_

map< string, vector< Real > >	netCvaSpreadSensi_

map< string, vector< Real > >	netCvaHazardRateSensi_

string	baseCurrency_

Real	quantile_

CollateralExposureHelper::CalculationType	calcType_

string	dvaName_

string	fvaBorrowingCurve_

string	fvaLendingCurve_

QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator >	dimCalculator_

QuantLib::ext::shared_ptr< ExposureCalculator >	exposureCalculator_

QuantLib::ext::shared_ptr< NettedExposureCalculator >	nettedExposureCalculator_

QuantLib::ext::shared_ptr< ValueAdjustmentCalculator >	cvaCalculator_

QuantLib::ext::shared_ptr< ValueAdjustmentCalculator >	allocatedCvaCalculator_

QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpretation_

bool	fullInitialCollateralisation_

vector< Period >	cvaSpreadSensiGrid_

vector< Time >	cvaSpreadSensiTimes_

Real	cvaSpreadSensiShiftSize_

Real	kvaCapitalDiscountRate_

Real	kvaAlpha_

Real	kvaRegAdjustment_

Real	kvaCapitalHurdle_

Real	kvaOurPdFloor_

Real	kvaTheirPdFloor_

Real	kvaOurCvaRiskWeight_

Real	kvaTheirCvaRiskWeight_

QuantLib::ext::shared_ptr< CreditSimulationParameters >	creditSimulationParameters_

std::vector< Real >	creditMigrationDistributionGrid_

std::vector< Size >	creditMigrationTimeSteps_

Matrix	creditStateCorrelationMatrix_

QuantLib::ext::shared_ptr< CreditMigrationCalculator >	creditMigrationCalculator_

std::vector< Real >	creditMigrationUpperBucketBounds_

std::vector< std::vector< Real > >	creditMigrationCdf_

std::vector< std::vector< Real > >	creditMigrationPdf_

bool	withMporStickyDate_

MporCashFlowMode	mporCashFlowMode_

Detailed Description

Exposure Aggregation and XVA Calculation.

This class aggregates NPV cube data, computes exposure statistics and various XVAs, all at trade and netting set level:

1) Exposures

Expected Positive Exposure, EPE: E[max(NPV(t),0) / N(t)]
Expected Negative Exposure, ENE: E[max(-NPV(t),0) / N(t)]
Basel Expected Exposure, EE_B: EPE(t)/P(t)
Basel Expected Positive Exposure, EPE_B
Basel Effective Expected Exposure, EEE_B: max( EEE_B(t-1), EE_B(t))
Basel Effective Expected Positive Exposure, EEPE_B
Potential Future Exposure, PFE: q-Quantile of the distribution of

2) Dynamic Initial Margin via regression

3) XVAs:

Credit Value Adjustment, CVA
Debit Value Adjustment, DVA
Funding Value Adjustment, FVA
Collateral Value Adjustment, COLVA
Margin Value Adjustment, MVA

4) Allocation from netting set to trade level such that allocated contributions add up to the netting set

CVA and DVA
EPE and ENE

All analytics are precomputed when the class constructor is called. A number of inspectors described below then return the individual analytics results.

Note:

exposures are discounted at the numeraire N(t) used in the Monte Carlo simulation which produces the NPV cube.
NPVs take collateral into account, depending on CSA settings

Definition at line 93 of file postprocess.hpp.

Constructor & Destructor Documentation

◆ PostProcess()

PostProcess	(	const QuantLib::ext::shared_ptr< Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< NettingSetManager > &	nettingSetManager,
		const QuantLib::ext::shared_ptr< CollateralBalances > &	collateralBalances,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	configuration,
		const QuantLib::ext::shared_ptr< NPVCube > &	cube,
		const QuantLib::ext::shared_ptr< AggregationScenarioData > &	scenarioData,
		const map< string, bool > &	analytics,
		const string &	baseCurrency,
		const string &	allocationMethod,
		Real	cvaMarginalAllocationLimit,
		Real	quantile = `0.95`,
		const string &	calculationType = `"Symmetric"`,
		const string &	dvaName = `""`,
		const string &	fvaBorrowingCurve = `""`,
		const string &	fvaLendingCurve = `""`,
		const QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator > &	dimCalculator = `QuantLib::ext::shared_ptr<DynamicInitialMarginCalculator>()`,
		const QuantLib::ext::shared_ptr< CubeInterpretation > &	cubeInterpretation = `QuantLib::ext::shared_ptr<CubeInterpretation>()`,
		bool	fullInitialCollateralisation = `false`,
		vector< Period >	cvaSpreadSensiGrid = `{6 * Months, 1 * Years, 3 * Years, 5 * Years, 10 * Years}`,
		Real	cvaSpreadSensiShiftSize = `0.0001`,
		Real	kvaCapitalDiscountRate = `0.10`,
		Real	kvaAlpha = `1.4`,
		Real	kvaRegAdjustment = `12.5`,
		Real	kvaCapitalHurdle = `0.012`,
		Real	kvaOurPdFloor = `0.03`,
		Real	kvaTheirPdFloor = `0.03`,
		Real	kvaOurCvaRiskWeight = `0.05`,
		Real	kvaTheirCvaRiskWeight = `0.05`,
		const QuantLib::ext::shared_ptr< NPVCube > &	cptyCube_ = `nullptr`,
		const string &	flipViewBorrowingCurvePostfix = `"_BORROW"`,
		const string &	flipViewLendingCurvePostfix = `"_LEND"`,
		const QuantLib::ext::shared_ptr< CreditSimulationParameters > &	creditSimulationParameters = `nullptr`,
		const std::vector< Real > &	creditMigrationDistributionGrid = `{}`,
		const std::vector< Size > &	creditMigrationTimeSteps = `{}`,
		const Matrix &	creditStateCorrelationMatrix = `Matrix()`,
		bool	withMporStickyDate = `false`,
		const MporCashFlowMode	mporCashFlowMode = `MporCashFlowMode::Unspecified`
	)

Constructor.

Parameters

portfolio	Trade portfolio to identify e.g. netting set, maturity, break dates for each trade
nettingSetManager	Netting set manager to access CSA details for each netting set
collateralBalances	Collateral balances (VM, IM, IA)
market	Market data object to access e.g. discounting and funding curves
configuration	Market configuration to use
cube	Input NPV Cube
scenarioData	Subset of simulated market data, index fixings and FX spot rates, associated with the NPV cube
analytics	Selection of analytics to be produced
baseCurrency	Expression currency for all results
allocationMethod	Method to be used for Exposure/XVA allocation down to trade level
cvaMarginalAllocationLimit	Cutoff parameter for the marginal allocation method below which we switch to equal distribution
quantile	Quantile for Potential Future Exposure output
calculationType	Collateral calculation type to be used, see class CollateralExposureHelper
dvaName	Credit curve name to be used for "our" credit risk in DVA calculations
fvaBorrowingCurve	Borrowing curve name to be used in FVA calculations
fvaLendingCurve	Lending curve name to be used in FVA calculations
dimCalculator	Dynamic Initial Margin Calculator
cubeInterpretation	Interpreter for cube storage (where to find which data items)
fullInitialCollateralisation	Assume t=0 collateral balance equals NPV (set to 0 if false)
cvaSpreadSensiGrid	CVA spread sensitivity grid
cvaSpreadSensiShiftSize	CVA spread sensitivity shift size
kvaCapitalDiscountRate	own capital discounting rate for discounting expected capital for KVA
kvaAlpha	alpha to adjust EEPE to give EAD for risk capital
kvaRegAdjustment	regulatory adjustment, 1/min cap requirement
kvaCapitalHurdle	Cost of Capital for KVA = regulatory adjustment x capital hurdle
kvaOurPdFloor	Our KVA PD floor
kvaTheirPdFloor	Their KVA PD floor
kvaOurCvaRiskWeight	Our KVA CVA Risk Weight
kvaTheirCvaRiskWeight	Their KVA CVA Risk Weight,
cptyCube_	Input Counterparty Cube
flipViewBorrowingCurvePostfix	Postfix for flipView borrowing curve for fva
flipViewLendingCurvePostfix	Postfix for flipView lending curve for fva
creditSimulationParameters	Credit simulation parameters
creditMigrationDistributionGrid	Credit simulation distribution grid
creditMigrationTimeSteps	Credit simulation time steps
creditStateCorrelationMatrix	Credit State correlation matrix
withMporStickyDate	If set to true, cash flows in the margin period of risk are ignored in the collateral modelling
mporCashFlowMode	Treatment of cash flows over the margin period of risk

Definition at line 55 of file postprocess.cpp.

: portfolio_(portfolio), nettingSetManager_(nettingSetManager), collateralBalances_(collateralBalances),
      market_(market), configuration_(configuration),
      cube_(cube), cptyCube_(cptyCube), scenarioData_(scenarioData), analytics_(analytics), baseCurrency_(baseCurrency),
      quantile_(quantile), calcType_(parseCollateralCalculationType(calculationType)), dvaName_(dvaName),
      fvaBorrowingCurve_(fvaBorrowingCurve), fvaLendingCurve_(fvaLendingCurve), dimCalculator_(dimCalculator),
      cubeInterpretation_(cubeInterpretation), fullInitialCollateralisation_(fullInitialCollateralisation),
      cvaSpreadSensiGrid_(cvaSensiGrid), cvaSpreadSensiShiftSize_(cvaSensiShiftSize),
      kvaCapitalDiscountRate_(kvaCapitalDiscountRate), kvaAlpha_(kvaAlpha), kvaRegAdjustment_(kvaRegAdjustment),
      kvaCapitalHurdle_(kvaCapitalHurdle), kvaOurPdFloor_(kvaOurPdFloor), kvaTheirPdFloor_(kvaTheirPdFloor),
      kvaOurCvaRiskWeight_(kvaOurCvaRiskWeight), kvaTheirCvaRiskWeight_(kvaTheirCvaRiskWeight),
      creditSimulationParameters_(creditSimulationParameters),
      creditMigrationDistributionGrid_(creditMigrationDistributionGrid),
      creditMigrationTimeSteps_(creditMigrationTimeSteps), creditStateCorrelationMatrix_(creditStateCorrelationMatrix),
      withMporStickyDate_(withMporStickyDate), mporCashFlowMode_(mporCashFlowMode) {
 
    QL_REQUIRE(cubeInterpretation_ != nullptr, "PostProcess: cubeInterpretation is not given.");
 
    if (mporCashFlowMode_ == MporCashFlowMode::Unspecified) {
        mporCashFlowMode_ = withMporStickyDate_ ? MporCashFlowMode::NonePay : MporCashFlowMode::BothPay;
    }
 
    QL_REQUIRE(!withMporStickyDate_ || mporCashFlowMode_ == MporCashFlowMode::NonePay,
               "PostProcess: MporMode StickyDate supports only MporCashFlowMode NonePay");
    QL_REQUIRE(cubeInterpretation_->storeFlows() || withMporStickyDate || mporCashFlowMode_ == MporCashFlowMode::BothPay,
               "PostProcess: If cube does not hold any mpor flows and MporMode is set to ActualDate, then "
               "MporCashFlowMode must "
               "be set to BothPay");
 
    bool isRegularCubeStorage = !cubeInterpretation_->withCloseOutLag();
 
    LOG("cube storage is regular: " << isRegularCubeStorage);
    LOG("cube dates: " << cube->dates().size());
 
    QL_REQUIRE(marginalAllocationLimit > 0.0, "positive allocationLimit expected");
 
    // check portfolio and cube have the same trade ids, in the same order
    QL_REQUIRE(portfolio->size() == cube_->idsAndIndexes().size(),
               "PostProcess::PostProcess(): portfolio size ("
                   << portfolio->size() << ") does not match cube trade size (" << cube_->idsAndIndexes().size() << ")");
    
    auto portfolioIt = portfolio->trades().begin();
    auto cubeIdIt = cube_->idsAndIndexes().begin();
    for (size_t i = 0; i < portfolio->size(); i++, portfolioIt++, cubeIdIt++) {
        const std::string& portfolioTradeId = portfolioIt->first;
        const std::string& cubeTradeId = cubeIdIt->first;
        QL_REQUIRE(portfolioTradeId == cubeTradeId, "PostProcess::PostProcess(): portfolio trade #"
                                                        << i << " (id=" << portfolioTradeId
                                                        << ") does not match cube trade id (" << cubeTradeId);
    }
 
    if (analytics_["dynamicCredit"]) {
        QL_REQUIRE(cptyCube_, "cptyCube cannot be null when dynamicCredit is ON");
        // check portfolio and cptyCube have the same counterparties, in the same order
        auto cptyIds = portfolio->counterparties();
        cptyIds.insert(dvaName_);
        QL_REQUIRE(cptyIds.size() == cptyCube_->idsAndIndexes().size(),
                   "PostProcess::PostProcess(): portfolio counterparty size ("
                       << cptyIds.size() << ") does not match cpty cube trade size ("
                       << cptyCube_->idsAndIndexes().size() << ")");
 
        auto cptyIt = cptyIds.begin();
        cubeIdIt = cptyCube_->idsAndIndexes().begin();
        for (size_t i = 0; i < cptyIds.size(); ++i, ++cptyIt, ++cubeIdIt) {
            const std::string& counterpartyId = *cptyIt;
            const std::string& cubeTradeId = cubeIdIt->first;
            QL_REQUIRE(counterpartyId == cubeTradeId, "PostProcess::PostProcess(): portfolio counterparty #"
                                                          << i << " (id=" << counterpartyId
                                                          << ") does not match cube name id (" << cubeTradeId);
        }
    }
 
    ExposureAllocator::AllocationMethod allocationMethod = parseAllocationMethod(allocMethod);
 
    /***********************************************
     * Step 0: Netting as of today
     * a) Compute the netting set NPV as of today
     * b) Find the final maturity of the netting set
     */
    LOG("Compute netting set NPVs as of today and netting set maturity");
    // Don't use Settings::instance().evaluationDate() here, this has moved to simulation end date.
    Date today = market->asofDate();
    LOG("AsOfDate = " << QuantLib::io::iso_date(today));
 
    /***************************************************************
     * Step 1: Dynamic Initial Margin calculation
     * Fills DIM cube per netting set that can be
     * - returned to be further analysed
     * - used in collateral calculation
     * - used in MVA calculation
     */
    if (analytics_["dim"] || analytics_["mva"]) {
        QL_REQUIRE(dimCalculator_, "DIM calculator not set");
        dimCalculator_->build();
    }
 
    /************************************************************
     * Step 2: Trade Exposure and Netting
     * a) Aggregation across scenarios per trade and date
     *    This yields single trade exposure profiles, EPE and ENE
     * b) Aggregation of NPVs within netting sets per date
     *    and scenario. This prepares the netting set exposure
     *    calculation below
     */
    exposureCalculator_ =
        QuantLib::ext::make_shared<ExposureCalculator>(
            portfolio, cube_, cubeInterpretation_,
            market_, analytics_["exerciseNextBreak"], baseCurrency_, configuration_,
            quantile_, calcType_, analytics_["dynamicCredit"], analytics_["flipViewXVA"]
        );
    exposureCalculator_->build();
 
    /******************************************************************
     * Step 3: Netting set exposure and allocation to trades
     *
     * a) Compute all netting set exposure profiles EPE and ENE using
     *    collateral if CSAs are given and active.
     * b) Compute the expected collateral balance for each netting set.
     * c) Allocate each netting set's exposure profile to the trade
     *    level such that the trade exposures add up to the netting
     *    set exposure.
     *    Reference:
     *    Michael Pykhtin & Dan Rosen, Pricing Counterparty Risk
     *    at the Trade Level and CVA Allocations, October 2010
     */
    nettedExposureCalculator_ = QuantLib::ext::make_shared<NettedExposureCalculator>(
        portfolio_, market_, cube_, baseCurrency, configuration_, quantile_, calcType_, analytics_["dynamicCredit"],
        nettingSetManager_, collateralBalances_, exposureCalculator_->nettingSetDefaultValue(),
        exposureCalculator_->nettingSetCloseOutValue(), exposureCalculator_->nettingSetMporPositiveFlow(),
        exposureCalculator_->nettingSetMporNegativeFlow(), scenarioData_, cubeInterpretation_, analytics_["dim"],
        dimCalculator_, fullInitialCollateralisation_,
        allocationMethod == ExposureAllocator::AllocationMethod::Marginal, marginalAllocationLimit,
        exposureCalculator_->exposureCube(), ExposureCalculator::allocatedEPE, ExposureCalculator::allocatedENE,
        analytics_["flipViewXVA"], withMporStickyDate_, mporCashFlowMode_);
    nettedExposureCalculator_->build();
 
    /********************************************************
     * Update Stand Alone XVAs
     * needed for some of the simple allocation methods below
     */
    if (analytics_["dynamicCredit"]) {
        cvaCalculator_ = QuantLib::ext::make_shared<DynamicCreditXvaCalculator>(
            portfolio_, market_, configuration_,baseCurrency_, dvaName_,
            fvaBorrowingCurve_, fvaLendingCurve_, analytics_["dim"],
            dimCalculator, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), cptyCube_,
            ExposureCalculator::ExposureIndex::EPE,
            ExposureCalculator::ExposureIndex::ENE,
            NettedExposureCalculator::ExposureIndex::EPE,
            NettedExposureCalculator::ExposureIndex::ENE, 0, analytics_["flipViewXVA"], 
            flipViewBorrowingCurvePostfix, flipViewLendingCurvePostfix);
    } else {
        cvaCalculator_ = QuantLib::ext::make_shared<StaticCreditXvaCalculator>(
            portfolio_, market_, configuration_,baseCurrency_, dvaName_,
            fvaBorrowingCurve_, fvaLendingCurve_, analytics_["dim"],
            dimCalculator, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(),
            ExposureCalculator::ExposureIndex::EPE,
            ExposureCalculator::ExposureIndex::ENE,
            NettedExposureCalculator::ExposureIndex::EPE,
            NettedExposureCalculator::ExposureIndex::ENE, analytics_["flipViewXVA"], 
            flipViewBorrowingCurvePostfix, flipViewLendingCurvePostfix);
    }
    cvaCalculator_->build();
 
    /***************************
     * Simple allocation methods
     */
    QuantLib::ext::shared_ptr<ExposureAllocator> exposureAllocator;
    if (allocationMethod == ExposureAllocator::AllocationMethod::Marginal) {
        DLOG("Marginal Calculation handled in NettedExposureCalculator");
    }
    else if (allocationMethod == ExposureAllocator::AllocationMethod::RelativeFairValueNet)
        exposureAllocator = QuantLib::ext::make_shared<RelativeFairValueNetExposureAllocator>(
            portfolio, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), cube_,
            ExposureCalculator::allocatedEPE, ExposureCalculator::allocatedENE,
            ExposureCalculator::EPE, ExposureCalculator::ENE,
            NettedExposureCalculator::EPE, NettedExposureCalculator::ENE);
    else if (allocationMethod == ExposureAllocator::AllocationMethod::RelativeFairValueGross)
        exposureAllocator = QuantLib::ext::make_shared<RelativeFairValueGrossExposureAllocator>(
            portfolio, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), cube_,
            ExposureCalculator::allocatedEPE, ExposureCalculator::allocatedENE,
            ExposureCalculator::EPE, ExposureCalculator::ENE,
            NettedExposureCalculator::EPE, NettedExposureCalculator::ENE);
    else if (allocationMethod == ExposureAllocator::AllocationMethod::RelativeXVA)
        exposureAllocator = QuantLib::ext::make_shared<RelativeXvaExposureAllocator>(
            portfolio, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), cube_,
            cvaCalculator_->tradeCva(), cvaCalculator_->tradeDva(),
            cvaCalculator_->nettingSetSumCva(), cvaCalculator_->nettingSetSumDva(),
            ExposureCalculator::allocatedEPE, ExposureCalculator::allocatedENE,
            ExposureCalculator::EPE, ExposureCalculator::ENE,
            NettedExposureCalculator::EPE, NettedExposureCalculator::ENE);
    else if (allocationMethod == ExposureAllocator::AllocationMethod::None)
        exposureAllocator = QuantLib::ext::make_shared<NoneExposureAllocator>(
            portfolio, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube());
    else
        QL_FAIL("allocationMethod " << allocationMethod << " not available");
    if(exposureAllocator)
        exposureAllocator->build();
 
    /********************************************************
     * Update Allocated XVAs
     */
    if (analytics_["dynamicCredit"]) {
        allocatedCvaCalculator_ = QuantLib::ext::make_shared<DynamicCreditXvaCalculator>(
            portfolio_, market_, configuration_, baseCurrency_, dvaName_, fvaBorrowingCurve_, fvaLendingCurve_,
            analytics_["dim"], dimCalculator, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), cptyCube_, ExposureCalculator::ExposureIndex::allocatedEPE,
            ExposureCalculator::ExposureIndex::allocatedENE, NettedExposureCalculator::ExposureIndex::EPE,
            NettedExposureCalculator::ExposureIndex::ENE, 0, analytics_["flipViewXVA"], flipViewBorrowingCurvePostfix,
            flipViewLendingCurvePostfix);
    } else {
        allocatedCvaCalculator_ = QuantLib::ext::make_shared<StaticCreditXvaCalculator>(
            portfolio_, market_, configuration_, baseCurrency_, dvaName_, fvaBorrowingCurve_, fvaLendingCurve_,
            analytics_["dim"], dimCalculator, exposureCalculator_->exposureCube(),
            nettedExposureCalculator_->exposureCube(), ExposureCalculator::ExposureIndex::allocatedEPE,
            ExposureCalculator::ExposureIndex::allocatedENE, NettedExposureCalculator::ExposureIndex::EPE,
            NettedExposureCalculator::ExposureIndex::ENE, analytics_["flipViewXVA"], flipViewBorrowingCurvePostfix,
            flipViewLendingCurvePostfix);
    }
    allocatedCvaCalculator_->build();
 
    /********************************************************
     * Cache average EPE and ENE
     */
    for (const auto& [tradeId,_]: tradeIds()) {
        tradeEPE_[tradeId] = exposureCalculator_->epe(tradeId);
        tradeENE_[tradeId] = exposureCalculator_->ene(tradeId);
        allocatedTradeEPE_[tradeId] = exposureCalculator_->allocatedEpe(tradeId);
        allocatedTradeENE_[tradeId] = exposureCalculator_->allocatedEne(tradeId);
    }
    for (const auto& [nettingSetId, pos] : nettingSetIds()) {
        netEPE_[nettingSetId] = nettedExposureCalculator_->epe(nettingSetId);
        netENE_[nettingSetId] = nettedExposureCalculator_->ene(nettingSetId);
    }
 
    /********************************************************
     * Calculate netting set KVA-CCR and KVA-CVA
     */
    updateNettingSetKVA();
 
    /***************************************
     * Calculate netting set CVA sensitivity
     */
    updateNettingSetCvaSensitivity();
 
    /***************************************
     * Credit migration analysis
     */
    if (analytics_["creditMigration"]) {
        creditMigrationCalculator_ = QuantLib::ext::make_shared<CreditMigrationCalculator>(
            portfolio_, creditSimulationParameters_, cube_, cubeInterpretation_,
            nettedExposureCalculator_->nettedCube(), scenarioData_, creditMigrationDistributionGrid_,
            creditMigrationTimeSteps_, creditStateCorrelationMatrix_, baseCurrency_);
        creditMigrationCalculator_->build();
        creditMigrationUpperBucketBounds_ = creditMigrationCalculator_->upperBucketBounds();
        creditMigrationCdf_ = creditMigrationCalculator_->cdf();
        creditMigrationPdf_ = creditMigrationCalculator_->pdf();
    }
}

Here is the call graph for this function:

Member Function Documentation

◆ setDimCalculator()

void setDimCalculator ( QuantLib::ext::shared_ptr< DynamicInitialMarginCalculator > dimCalculator )

Definition at line 174 of file postprocess.hpp.

                                                                                               {
        dimCalculator_ = dimCalculator;
    }

◆ spreadSensitivityTimes()

const vector< Real > & spreadSensitivityTimes ( )

Definition at line 178 of file postprocess.hpp.

178{ return cvaSpreadSensiTimes_; }

ore::analytics::PostProcess::cvaSpreadSensiTimes_

vector< Time > cvaSpreadSensiTimes_

Definition: postprocess.hpp:363

◆ spreadSensitivityGrid()

const vector< Period > & spreadSensitivityGrid ( )

Definition at line 179 of file postprocess.hpp.

179{ return cvaSpreadSensiGrid_; }

◆ tradeIds()

const std::map< string, Size > tradeIds ( )

Return list of Trade IDs in the portfolio.

Definition at line 182 of file postprocess.hpp.

                                          {
        return cube()->idsAndIndexes();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nettingSetIds()

const std::map< string, Size > nettingSetIds ( )

Return list of netting set IDs in the portfolio.

Definition at line 186 of file postprocess.hpp.

                                               {
        return netCube()->idsAndIndexes();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ counterpartyId()

const map< string, string > & counterpartyId ( )

Return the map of counterparty Ids.

Definition at line 190 of file postprocess.hpp.

190{ return nettedExposureCalculator_->counterpartyMap(); }

Here is the caller graph for this function:

◆ tradeEPE()

const vector< Real > & tradeEPE ( const string & tradeId )

Return trade level Expected Positive Exposure evolution.

Definition at line 594 of file postprocess.cpp.

                                                               {
    QL_REQUIRE(tradeEPE_.find(tradeId) != tradeEPE_.end(), "Trade " << tradeId << " not found in exposure map");
    return tradeEPE_[tradeId];
}

◆ tradeENE()

const vector< Real > & tradeENE ( const string & tradeId )

Return trade level Expected Negative Exposure evolution.

Definition at line 599 of file postprocess.cpp.

                                                               {
    QL_REQUIRE(tradeENE_.find(tradeId) != tradeENE_.end(), "Trade " << tradeId << " not found in exposure map");
    return tradeENE_[tradeId];
}

◆ tradeEE_B()

const vector< Real > & tradeEE_B ( const string & tradeId )

Return trade level Basel Expected Exposure evolution.

Definition at line 604 of file postprocess.cpp.

                                                                {
    return exposureCalculator_->ee_b(tradeId);
}

◆ tradeEPE_B()

const Real & tradeEPE_B ( const string & tradeId )

Return trade level Basel Expected Positive Exposure evolution.

Definition at line 608 of file postprocess.cpp.

                                                         {
    return exposureCalculator_->epe_b(tradeId);
}

◆ tradeEEE_B()

const vector< Real > & tradeEEE_B ( const string & tradeId )

Return trade level Effective Expected Exposure evolution.

Definition at line 612 of file postprocess.cpp.

                                                                 {
    return exposureCalculator_->eee_b(tradeId);
}

◆ tradeEEPE_B()

const Real & tradeEEPE_B ( const string & tradeId )

Return trade level Effective Expected Positive Exposure evolution.

Definition at line 616 of file postprocess.cpp.

                                                          {
    return exposureCalculator_->eepe_b(tradeId);
}

◆ tradePFE()

const vector< Real > & tradePFE ( const string & tradeId )

Return trade level Potential Future Exposure evolution.

Definition at line 620 of file postprocess.cpp.

                                                               {
    return exposureCalculator_->pfe(tradeId);
}

◆ netEPE()

const vector< Real > & netEPE ( const string & nettingSetId )

Return Netting Set Expected Positive Exposure evolution.

Definition at line 624 of file postprocess.cpp.

                                                                  {
    QL_REQUIRE(netEPE_.find(nettingSetId) != netEPE_.end(),
               "Netting set " << nettingSetId << " not found in exposure map");
    return netEPE_[nettingSetId];
}

◆ netENE()

const vector< Real > & netENE ( const string & nettingSetId )

Return Netting Set Expected Negative Exposure evolution.

Definition at line 630 of file postprocess.cpp.

                                                                  {
    QL_REQUIRE(netENE_.find(nettingSetId) != netENE_.end(),
               "Netting set " << nettingSetId << " not found in exposure map");
    return netENE_[nettingSetId];
}

◆ netEE_B()

const vector< Real > & netEE_B ( const string & nettingSetId )

Return Netting Set Basel Expected Exposure evolution.

Definition at line 650 of file postprocess.cpp.

                                                                   {
    return nettedExposureCalculator_->ee_b(nettingSetId);
}

◆ netEPE_B()

const Real & netEPE_B ( const string & nettingSetId )

Return Netting Set Basel Expected Positive Exposure evolution.

Definition at line 654 of file postprocess.cpp.

                                                            {
    return nettedExposureCalculator_->epe_b(nettingSetId);
}

◆ netEEE_B()

const vector< Real > & netEEE_B ( const string & nettingSetId )

Return Netting Set Effective Expected Exposure evolution.

Definition at line 658 of file postprocess.cpp.

                                                                    {
    return nettedExposureCalculator_->eee_b(nettingSetId);
}

◆ netEEPE_B()

const Real & netEEPE_B ( const string & nettingSetId )

Return Netting Set Effective Expected Positive Exposure evolution.

Definition at line 662 of file postprocess.cpp.

                                                             {
    return nettedExposureCalculator_->eepe_b(nettingSetId);
}

◆ netPFE()

const vector< Real > & netPFE ( const string & nettingSetId )

Return Netting Set Potential Future Exposure evolution.

Definition at line 666 of file postprocess.cpp.

                                                                  {
    return nettedExposureCalculator_->pfe(nettingSetId);
}

◆ expectedCollateral()

const vector< Real > & expectedCollateral ( const string & nettingSetId )

Return the netting set's expected collateral evolution.

Definition at line 670 of file postprocess.cpp.

                                                                              {
    return nettedExposureCalculator_->expectedCollateral(nettingSetId);
}

◆ colvaIncrements()

const vector< Real > & colvaIncrements ( const string & nettingSetId )

Return the netting set's expected COLVA increments through time.

Definition at line 674 of file postprocess.cpp.

                                                                           {
    return nettedExposureCalculator_->colvaIncrements(nettingSetId);
}

◆ collateralFloorIncrements()

const vector< Real > & collateralFloorIncrements ( const string & nettingSetId )

Return the netting set's expected Collateral Floor increments through time.

Definition at line 678 of file postprocess.cpp.

                                                                                     {
    return nettedExposureCalculator_->collateralFloorIncrements(nettingSetId);
}

◆ allocatedTradeEPE()

const vector< Real > & allocatedTradeEPE ( const string & tradeId )

Return the trade EPE, allocated down from the netting set level.

Definition at line 682 of file postprocess.cpp.

                                                                        {
    QL_REQUIRE(allocatedTradeEPE_.find(tradeId) != allocatedTradeEPE_.end(),
               "Trade " << tradeId << " not found in exposure map");
    return allocatedTradeEPE_[tradeId];
}

◆ allocatedTradeENE()

const vector< Real > & allocatedTradeENE ( const string & tradeId )

Return trade ENE, allocated down from the netting set level.

Definition at line 688 of file postprocess.cpp.

                                                                        {
    QL_REQUIRE(allocatedTradeENE_.find(tradeId) != allocatedTradeENE_.end(),
               "Trade " << tradeId << " not found in exposure map");
    return allocatedTradeENE_[tradeId];
}

◆ netCvaHazardRateSensitivity()

vector< Real > netCvaHazardRateSensitivity ( const string & nettingSetId )

Return Netting Set CVA Hazard Rate Sensitivity vector.

Definition at line 636 of file postprocess.cpp.

                                                                                {
    if (netCvaHazardRateSensi_.find(nettingSetId) != netCvaHazardRateSensi_.end())
        return netCvaHazardRateSensi_[nettingSetId];
    else
        return vector<Real>();
}

◆ netCvaSpreadSensitivity() [1/2]

vector< Real > netCvaSpreadSensitivity ( const string & nettingSetId )

Return Netting Set CVA Spread Sensitivity vector.

Definition at line 643 of file postprocess.cpp.

                                                                            {
    if (netCvaSpreadSensi_.find(nettingSetId) != netCvaSpreadSensi_.end())
        return netCvaSpreadSensi_[nettingSetId];
    else
        return vector<Real>();
}

◆ netCvaSpreadSensitivity() [2/2]

const std::map< std::string, std::vector< QuantLib::Real > > & netCvaSpreadSensitivity ( ) const

Return Netting Set CVA Spread Sensitivity vector.

Definition at line 241 of file postprocess.hpp.

241{ return netCvaSpreadSensi_; }

◆ tradeCVA()

Real tradeCVA ( const string & tradeId )

Return trade (stand-alone) CVA.

Definition at line 694 of file postprocess.cpp.

                                                {
    return cvaCalculator_->tradeCva(tradeId);
}

◆ tradeDVA()

Real tradeDVA ( const string & tradeId )

Return trade (stand-alone) DVA.

Definition at line 698 of file postprocess.cpp.

                                                {
    return cvaCalculator_->tradeDva(tradeId);
}

◆ tradeMVA()

Real tradeMVA ( const string & tradeId )

Return trade (stand-alone) MVA.

Definition at line 702 of file postprocess.cpp.

                                                {
    return cvaCalculator_->tradeMva(tradeId);
}

◆ tradeFBA()

Real tradeFBA ( const string & tradeId )

Return trade (stand-alone) FBA (Funding Benefit Adjustment)

Definition at line 706 of file postprocess.cpp.

                                                {
    return cvaCalculator_->tradeFba(tradeId);
}

◆ tradeFCA()

Real tradeFCA ( const string & tradeId )

Return trade (stand-alone) FCA (Funding Cost Adjustment)

Definition at line 710 of file postprocess.cpp.

                                                {
    return cvaCalculator_->tradeFca(tradeId);
}

◆ tradeFBA_exOwnSP()

Real tradeFBA_exOwnSP ( const string & tradeId )

Return trade (stand-alone) FBA (Funding Benefit Adjustment) excluding own survival probability.

Definition at line 714 of file postprocess.cpp.

                                                        {
    return cvaCalculator_->tradeFba_exOwnSp(tradeId);
}

◆ tradeFCA_exOwnSP()

Real tradeFCA_exOwnSP ( const string & tradeId )

Return trade (stand-alone) FCA (Funding Cost Adjustment) excluding own survival probability.

Definition at line 718 of file postprocess.cpp.

                                                        {
    return cvaCalculator_->tradeFca_exOwnSp(tradeId);
}

◆ tradeFBA_exAllSP()

Real tradeFBA_exAllSP ( const string & tradeId )

Return trade (stand-alone) FBA (Funding Benefit Adjustment) excluding both survival probabilities.

Definition at line 722 of file postprocess.cpp.

                                                        {
    return cvaCalculator_->tradeFba_exAllSp(tradeId);
}

◆ tradeFCA_exAllSP()

Real tradeFCA_exAllSP ( const string & tradeId )

Return trade (stand-alone) FCA (Funding Cost Adjustment) excluding both survival probabilities.

Definition at line 726 of file postprocess.cpp.

                                                        {
    return cvaCalculator_->tradeFca_exAllSp(tradeId);
}

◆ allocatedTradeCVA()

Real allocatedTradeCVA ( const string & tradeId )

Return allocated trade CVA (trade CVAs add up to netting set CVA)

Definition at line 793 of file postprocess.cpp.

                                                                  {
    return allocatedCvaCalculator_->tradeCva(allocatedTradeId);
}

◆ allocatedTradeDVA()

Real allocatedTradeDVA ( const string & tradeId )

Return allocated trade DVA (trade DVAs add up to netting set DVA)

Definition at line 797 of file postprocess.cpp.

                                                                  {
    return allocatedCvaCalculator_->tradeDva(allocatedTradeId);
}

◆ nettingSetCVA()

Real nettingSetCVA ( const string & nettingSetId )

Return netting set CVA.

Definition at line 730 of file postprocess.cpp.

                                                          {
    return cvaCalculator_->nettingSetCva(nettingSetId);
}

◆ nettingSetDVA()

Real nettingSetDVA ( const string & nettingSetId )

Return netting set DVA.

Definition at line 734 of file postprocess.cpp.

                                                          {
    return cvaCalculator_->nettingSetDva(nettingSetId);
}

◆ nettingSetMVA()

Real nettingSetMVA ( const string & nettingSetId )

Return netting set MVA.

Definition at line 738 of file postprocess.cpp.

                                                          {
    return cvaCalculator_->nettingSetMva(nettingSetId);
 
}

◆ nettingSetFBA()

Real nettingSetFBA ( const string & nettingSetId )

Return netting set FBA.

Definition at line 743 of file postprocess.cpp.

                                                          {
    return cvaCalculator_->nettingSetFba(nettingSetId);
 
}

◆ nettingSetFCA()

Real nettingSetFCA ( const string & nettingSetId )

Return netting set FCA.

Definition at line 748 of file postprocess.cpp.

                                                          {
    return cvaCalculator_->nettingSetFca(nettingSetId);
 
}

◆ nettingSetOurKVACCR()

Real nettingSetOurKVACCR ( const string & nettingSetId )

Return netting set KVA-CCR.

Definition at line 753 of file postprocess.cpp.

                                                                {
    QL_REQUIRE(ourNettingSetKVACCR_.find(nettingSetId) != ourNettingSetKVACCR_.end(),
               "NettingSetId " << nettingSetId << " not found in nettingSet KVACCR map");
    return ourNettingSetKVACCR_[nettingSetId];
}

◆ nettingSetTheirKVACCR()

Real nettingSetTheirKVACCR ( const string & nettingSetId )

Return netting set KVA-CCR from counterparty perspective.

Definition at line 759 of file postprocess.cpp.

                                                                  {
    QL_REQUIRE(theirNettingSetKVACCR_.find(nettingSetId) != theirNettingSetKVACCR_.end(),
               "NettingSetId " << nettingSetId << " not found in nettingSet KVACCR map");
    return theirNettingSetKVACCR_[nettingSetId];
}

◆ nettingSetOurKVACVA()

Real nettingSetOurKVACVA ( const string & nettingSetId )

Return netting set KVA-CVA.

Definition at line 765 of file postprocess.cpp.

                                                                {
    QL_REQUIRE(ourNettingSetKVACVA_.find(nettingSetId) != ourNettingSetKVACVA_.end(),
               "NettingSetId " << nettingSetId << " not found in nettingSet KVACVA map");
    return ourNettingSetKVACVA_[nettingSetId];
}

◆ nettingSetTheirKVACVA()

Real nettingSetTheirKVACVA ( const string & nettingSetId )

Return netting set KVA-CVA from counterparty perspective.

Definition at line 771 of file postprocess.cpp.

                                                                  {
    QL_REQUIRE(theirNettingSetKVACVA_.find(nettingSetId) != theirNettingSetKVACVA_.end(),
               "NettingSetId " << nettingSetId << " not found in nettingSet KVACVA map");
    return theirNettingSetKVACVA_[nettingSetId];
}

◆ nettingSetFBA_exOwnSP()

Real nettingSetFBA_exOwnSP ( const string & nettingSetId )

Return netting set FBA excluding own survival probability.

Definition at line 777 of file postprocess.cpp.

                                                                  {
    return cvaCalculator_->nettingSetFba_exOwnSp(nettingSetId);
}

◆ nettingSetFCA_exOwnSP()

Real nettingSetFCA_exOwnSP ( const string & nettingSetId )

Return netting set FCA excluding own survival probability.

Definition at line 781 of file postprocess.cpp.

                                                                  {
    return cvaCalculator_->nettingSetFca_exOwnSp(nettingSetId);
}

◆ nettingSetFBA_exAllSP()

Real nettingSetFBA_exAllSP ( const string & nettingSetId )

Return netting set FBA excluding both survival probabilities.

Definition at line 785 of file postprocess.cpp.

                                                                  {
    return cvaCalculator_->nettingSetFba_exAllSp(nettingSetId);
}

◆ nettingSetFCA_exAllSP()

Real nettingSetFCA_exAllSP ( const string & nettingSetId )

Return netting set FCA excluding both survival probabilities.

Definition at line 789 of file postprocess.cpp.

                                                                  {
    return cvaCalculator_->nettingSetFca_exAllSp(nettingSetId);
}

◆ nettingSetCOLVA()

Real nettingSetCOLVA ( const string & nettingSetId )

Return netting set COLVA.

Definition at line 801 of file postprocess.cpp.

                                                            {
    return nettedExposureCalculator_->colva(nettingSetId);
}

◆ nettingSetCollateralFloor()

Real nettingSetCollateralFloor ( const string & nettingSetId )

Return netting set Collateral Floor value.

Definition at line 805 of file postprocess.cpp.

                                                                      {
    return nettedExposureCalculator_->collateralFloor(nettingSetId);
}

◆ cube()

const QuantLib::ext::shared_ptr< NPVCube > & cube ( )

Inspector for the input NPV cube (by trade, time, scenario)

Definition at line 297 of file postprocess.hpp.

297{ return cube_; }

Here is the caller graph for this function:

◆ cptyCube()

const QuantLib::ext::shared_ptr< NPVCube > & cptyCube ( )

Inspector for the input Cpty cube (by name, time, scenario)

Definition at line 299 of file postprocess.hpp.

299{ return cptyCube_; }

◆ netCube()

const QuantLib::ext::shared_ptr< NPVCube > & netCube ( )

Return the for the input NPV cube after netting and collateral (by netting set, time, scenario)

Definition at line 301 of file postprocess.hpp.

301{ return nettedExposureCalculator_->nettedCube(); }

Here is the caller graph for this function:

◆ exportDimEvolution()

void exportDimEvolution ( ore::data::Report & dimEvolutionReport )

Return the dynamic initial margin cube (regression approach)

Write average (over samples) DIM evolution through time for all netting sets

Definition at line 809 of file postprocess.cpp.

                                                                      {
    dimCalculator_->exportDimEvolution(dimEvolutionReport);
}

◆ exportDimRegression()

void exportDimRegression	(	const std::string &	nettingSet,
		const std::vector< Size > &	timeSteps,
		const std::vector< QuantLib::ext::shared_ptr< ore::data::Report > > &	dimRegReports
	)

Write DIM as a function of sample netting set NPV for a given time step.

Definition at line 813 of file postprocess.cpp.

                                                                                                            {
 
    QuantLib::ext::shared_ptr<RegressionDynamicInitialMarginCalculator> regCalc =
        QuantLib::ext::dynamic_pointer_cast<RegressionDynamicInitialMarginCalculator>(dimCalculator_);
 
    if (regCalc)
        regCalc->exportDimRegression(nettingSet, timeSteps, dimRegReports);
}

◆ cvaSpreadSensiShiftSize()

QuantLib::Real cvaSpreadSensiShiftSize ( )

get the cvaSpreadSensiShiftSize

Definition at line 311 of file postprocess.hpp.

311{ return cvaSpreadSensiShiftSize_; }

◆ creditMigrationUpperBucketBounds()

const std::vector< Real > & creditMigrationUpperBucketBounds ( ) const

get the credit migration pnl distributions for each time step

Definition at line 314 of file postprocess.hpp.

314{ return creditMigrationUpperBucketBounds_; }

◆ creditMigrationCdf()

const std::vector< std::vector< Real > > & creditMigrationCdf ( ) const

Definition at line 315 of file postprocess.hpp.

315{ return creditMigrationCdf_; }

◆ creditMigrationPdf()

const std::vector< std::vector< Real > > & creditMigrationPdf ( ) const

Definition at line 316 of file postprocess.hpp.

316{ return creditMigrationPdf_; }

◆ collateralPaths()

QuantLib::ext::shared_ptr< vector< QuantLib::ext::shared_ptr< CollateralAccount > > > collateralPaths	(	const string &	nettingSetId,
		const QuantLib::ext::shared_ptr< NettingSetManager > &	nettingSetManager,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	configuration,
		const QuantLib::ext::shared_ptr< AggregationScenarioData > &	scenarioData,
		Size	dates,
		Size	samples,
		const vector< vector< Real > > &	nettingSetValue,
		Real	nettingSetValueToday,
		const Date &	nettingSetMaturity
	)

protected

Helper function to return the collateral account evolution for a given netting set.

◆ updateNettingSetKVA()

void updateNettingSetKVA ( )

protected

Definition at line 335 of file postprocess.cpp.

                                      {
 
    // Loop over all netting sets
    for (const auto& [nettingSetId,pos] : nettingSetIds()) {
        // Init results
        ourNettingSetKVACCR_[nettingSetId] = 0.0;
        theirNettingSetKVACCR_[nettingSetId] = 0.0;
        ourNettingSetKVACVA_[nettingSetId] = 0.0;
        theirNettingSetKVACVA_[nettingSetId] = 0.0;
    }
 
    if (!analytics_["kva"])
        return;
 
    LOG("Update netting set KVA");
    
    vector<Date> dateVector = cube_->dates();
    Size dates = dateVector.size();
    Date today = market_->asofDate();
    Handle<YieldTermStructure> discountCurve = market_->discountCurve(baseCurrency_, configuration_);
    DayCounter dc = ActualActual(ActualActual::ISDA);
 
    // Loop over all netting sets
    for (const auto& [nettingSetId, pos] : nettingSetIds()) {
        string cid;
        if (analytics_["flipViewXVA"]) {
            cid = dvaName_;
        } else {
            cid = nettedExposureCalculator_->counterparty(nettingSetId);
        }
        LOG("KVA for netting set " << nettingSetId);
 
        // Main input are the EPE and ENE profiles, previously computed
        vector<Real> epe = netEPE_[nettingSetId];
        vector<Real> ene = netENE_[nettingSetId];
 
        // PD from counterparty Dts, floored to avoid 0 ...
        // Today changed to today+1Y to get the one-year PD
        Handle<DefaultProbabilityTermStructure> cvaDts = market_->defaultCurve(cid, configuration_)->curve();
        QL_REQUIRE(!cvaDts.empty(), "Default curve missing for counterparty " << cid);
        Real cvaRR = market_->recoveryRate(cid, configuration_)->value();
        Real PD1 = std::max(cvaDts->defaultProbability(today + 1 * Years), 0.000000000001);
        Real LGD1 = (1 - cvaRR);
 
        // FIXME: if flipViewXVA is sufficient, then all code for their KVA-CCR could be discarded here...
        Handle<DefaultProbabilityTermStructure> dvaDts;
        Real dvaRR = 0.0;
        Real PD2 = 0;
        if (analytics_["flipViewXVA"]) {
            dvaName_ = nettedExposureCalculator_->counterparty(nettingSetId);
        }
        if (dvaName_ != "") {
            dvaDts = market_->defaultCurve(dvaName_, configuration_)->curve();
            dvaRR = market_->recoveryRate(dvaName_, configuration_)->value();
            PD2 = std::max(dvaDts->defaultProbability(today + 1 * Years), 0.000000000001);
        } else {
            ALOG("dvaName not specified, own PD set to zero for their KVA calculation");
        }
        Real LGD2 = (1 - dvaRR);
 
        // Granularity adjustment, Gordy (2004):
        Real rho1 = 0.12 * (1 - std::exp(-50 * PD1)) / (1 - std::exp(-50)) +
                    0.24 * (1 - (1 - std::exp(-50 * PD1)) / (1 - std::exp(-50)));
        Real rho2 = 0.12 * (1 - std::exp(-50 * PD2)) / (1 - std::exp(-50)) +
                    0.24 * (1 - (1 - std::exp(-50 * PD2)) / (1 - std::exp(-50)));
 
        // Basel II internal rating based (IRB) estimate of worst case PD:
        // Large homogeneous pool (LHP) approximation of Vasicek (1997)
        InverseCumulativeNormal icn;
        CumulativeNormalDistribution cnd;
        Real PD99_1 = cnd((icn(PD1) + std::sqrt(rho1) * icn(0.999)) / (std::sqrt(1 - rho1))) - PD1;
        Real PD99_2 = cnd((icn(PD2) + std::sqrt(rho2) * icn(0.999)) / (std::sqrt(1 - rho2))) - PD2;
 
        // KVA regulatory PD, worst case PD, floored at 0.03 for corporates and banks, not floored for sovereigns
        Real kva99PD1 = std::max(PD99_1, kvaTheirPdFloor_);
        Real kva99PD2 = std::max(PD99_2, kvaOurPdFloor_);
 
        // Factor B(PD) for the maturity adjustment factor, B(PD) = (0.11852 - 0.05478 * ln(PD)) ^ 2
        Real kvaMatAdjB1 = std::pow((0.11852 - 0.05478 * std::log(PD1)), 2.0);
        Real kvaMatAdjB2 = std::pow((0.11852 - 0.05478 * std::log(PD2)), 2.0);
 
        DLOG("Our KVA-CCR " << nettingSetId << ": PD=" << PD1);
        DLOG("Our KVA-CCR " << nettingSetId << ": LGD=" << LGD1);
        DLOG("Our KVA-CCR " << nettingSetId << ": rho=" << rho1);
        DLOG("Our KVA-CCR " << nettingSetId << ": PD99=" << PD99_1);
        DLOG("Our KVA-CCR " << nettingSetId << ": PD Floor=" << kvaTheirPdFloor_);
        DLOG("Our KVA-CCR " << nettingSetId << ": Floored PD99=" << kva99PD1);
        DLOG("Our KVA-CCR " << nettingSetId << ": B(PD)=" << kvaMatAdjB1);
 
        DLOG("Their KVA-CCR " << nettingSetId << ": PD=" << PD2);
        DLOG("Their KVA-CCR " << nettingSetId << ": LGD=" << LGD2);
        DLOG("Their KVA-CCR " << nettingSetId << ": rho=" << rho2);
        DLOG("Their KVA-CCR " << nettingSetId << ": PD99=" << PD99_2);
        DLOG("Their KVA-CCR " << nettingSetId << ": PD Floor=" << kvaOurPdFloor_);
        DLOG("Their KVA-CCR " << nettingSetId << ": Floored PD99=" << kva99PD2);
        DLOG("Their KVA-CCR " << nettingSetId << ": B(PD)=" << kvaMatAdjB2);
 
        for (Size j = 0; j < dates; ++j) {
            Date d0 = j == 0 ? today : cube_->dates()[j - 1];
            Date d1 = cube_->dates()[j];
 
            // Preprocess:
            // 1) Effective maturity from effective expected exposure as of time j
            //    Index _1 corresponds to our perspective, index _2 to their perspective.
            // 2) Basel EEPE as of time j, i.e. as time average over EEE, starting at time j
            // More accuracy may be achieved here by using a Longstaff-Schwartz method / regression
            Real eee_kva_1 = 0.0, eee_kva_2 = 0.0;
            Real effMatNumer1 = 0.0, effMatNumer2 = 0.0;
            Real effMatDenom1 = 0.0, effMatDenom2 = 0.0;
            Real eepe_kva_1 = 0, eepe_kva_2 = 0.0;
            Size kmax = j, count = 0;
            // Cut off index for EEPE/EENE calculation: One year ahead
            while (dateVector[kmax] < dateVector[j] + 1 * Years + 4 * Days && kmax < dates - 1)
                kmax++;
            Real sumdt = 0.0, eee1_b = 0.0, eee2_b = 0.0;
            for (Size k = j; k < dates; ++k) {
                Date d2 = cube_->dates()[k];
                Date prevDate = k == 0 ? today : dateVector[k - 1];
 
                eee_kva_1 = std::max(eee_kva_1, epe[k + 1]);
                eee_kva_2 = std::max(eee_kva_2, ene[k + 1]);
 
                // Components of the KVA maturity adjustment MA as of time j
                if (dc.yearFraction(d1, d2) > 1.0) {
                    effMatNumer1 += epe[k + 1] * dc.yearFraction(prevDate, d2);
                    effMatNumer2 += ene[k + 1] * dc.yearFraction(prevDate, d2);
                }
                if (dc.yearFraction(d1, d2) <= 1.0) {
                    effMatDenom1 += eee_kva_1 * dc.yearFraction(prevDate, d2);
                    effMatDenom2 += eee_kva_2 * dc.yearFraction(prevDate, d2);
                }
 
                if (k < kmax) {
                    Real dt = dc.yearFraction(cube_->dates()[k], cube_->dates()[k + 1]);
                    sumdt += dt;
                    Real epe_b = epe[k + 1] / discountCurve->discount(dateVector[k]);
                    Real ene_b = ene[k + 1] / discountCurve->discount(dateVector[k]);
                    eee1_b = std::max(epe_b, eee1_b);
                    eee2_b = std::max(ene_b, eee2_b);
                    eepe_kva_1 += eee1_b * dt;
                    eepe_kva_2 += eee2_b * dt;
                    count++;
                }
            }
 
            // Normalize EEPE/EENE calculation
            eepe_kva_1 = count > 0 ? eepe_kva_1 / sumdt : 0.0;
            eepe_kva_2 = count > 0 ? eepe_kva_2 / sumdt : 0.0;
 
            // KVA CCR using the IRB risk weighted asset method and IMM:
            // KVA effective maturity of the nettingSet, capped at 5
            Real kvaNWMaturity1 = std::min(1.0 + (effMatDenom1 == 0.0 ? 0.0 : effMatNumer1 / effMatDenom1), 5.0);
            Real kvaNWMaturity2 = std::min(1.0 + (effMatDenom2 == 0.0 ? 0.0 : effMatNumer2 / effMatDenom2), 5.0);
 
            // Maturity adjustment factor for the RWA method:
            // MA(PD, M) = (1 + (M - 2.5) * B(PD)) / (1 - 1.5 * B(PD)), capped at 5, floored at 1, M = effective
            // maturity
            Real kvaMatAdj1 =
                std::max(std::min((1.0 + (kvaNWMaturity1 - 2.5) * kvaMatAdjB1) / (1.0 - 1.5 * kvaMatAdjB1), 5.0), 1.0);
            Real kvaMatAdj2 =
                std::max(std::min((1.0 + (kvaNWMaturity2 - 2.5) * kvaMatAdjB2) / (1.0 - 1.5 * kvaMatAdjB2), 5.0), 1.0);
 
            // CCR Capital: RC = EAD x LGD x PD99.9 x MA(PD, M); EAD = alpha x EEPE(t) (approximated by EPE here);
            Real kvaRC1 = kvaAlpha_ * eepe_kva_1 * LGD1 * kva99PD1 * kvaMatAdj1;
            Real kvaRC2 = kvaAlpha_ * eepe_kva_2 * LGD2 * kva99PD2 * kvaMatAdj2;
 
            // Expected risk capital discounted at capital discount rate
            Real kvaCapitalDiscount = 1 / std::pow(1 + kvaCapitalDiscountRate_, dc.yearFraction(today, d0));
            Real kvaCCRIncrement1 =
                kvaRC1 * kvaCapitalDiscount * dc.yearFraction(d0, d1) * kvaCapitalHurdle_ * kvaRegAdjustment_;
            Real kvaCCRIncrement2 =
                kvaRC2 * kvaCapitalDiscount * dc.yearFraction(d0, d1) * kvaCapitalHurdle_ * kvaRegAdjustment_;
 
            ourNettingSetKVACCR_[nettingSetId] += kvaCCRIncrement1;
            theirNettingSetKVACCR_[nettingSetId] += kvaCCRIncrement2;
 
            DLOG("Our KVA-CCR for " << nettingSetId << ": " << j << " EEPE=" << setprecision(2) << eepe_kva_1
                                    << " EPE=" << epe[j] << " RC=" << kvaRC1 << " M=" << setprecision(6)
                                    << kvaNWMaturity1 << " MA=" << kvaMatAdj1 << " Cost=" << setprecision(2)
                                    << kvaCCRIncrement1 << " KVA=" << ourNettingSetKVACCR_[nettingSetId]);
            DLOG("Their KVA-CCR for " << nettingSetId << ": " << j << " EENE=" << eepe_kva_2 << " ENE=" << ene[j]
                                      << " RC=" << kvaRC2 << " M=" << setprecision(6) << kvaNWMaturity2
                                      << " MA=" << kvaMatAdj2 << " Cost=" << setprecision(2) << kvaCCRIncrement2
                                      << " KVA=" << theirNettingSetKVACCR_[nettingSetId]);
 
            // CVA Capital
            // effective maturity without cap at 5, DF set to 1 for IMM banks
            // TODO: Set MA in CCR capital calculation to 1
            Real kvaCvaMaturity1 = 1.0 + (effMatDenom1 == 0.0 ? 0.0 : effMatNumer1 / effMatDenom1);
            Real kvaCvaMaturity2 = 1.0 + (effMatDenom2 == 0.0 ? 0.0 : effMatNumer2 / effMatDenom2);
            Real scva1 = kvaTheirCvaRiskWeight_ * kvaCvaMaturity1 * eepe_kva_1;
            Real scva2 = kvaOurCvaRiskWeight_ * kvaCvaMaturity2 * eepe_kva_2;
            Real kvaCVAIncrement1 =
                scva1 * kvaCapitalDiscount * dc.yearFraction(d0, d1) * kvaCapitalHurdle_ * kvaRegAdjustment_;
            Real kvaCVAIncrement2 =
                scva2 * kvaCapitalDiscount * dc.yearFraction(d0, d1) * kvaCapitalHurdle_ * kvaRegAdjustment_;
 
            DLOG("Our KVA-CVA for " << nettingSetId << ": " << j << " EEPE=" << eepe_kva_1 << " SCVA=" << scva1
                                    << " Cost=" << kvaCVAIncrement1);
            DLOG("Their KVA-CVA for " << nettingSetId << ": " << j << " EENE=" << eepe_kva_2 << " SCVA=" << scva2
                                      << " Cost=" << kvaCVAIncrement2);
 
            ourNettingSetKVACVA_[nettingSetId] += kvaCVAIncrement1;
            theirNettingSetKVACVA_[nettingSetId] += kvaCVAIncrement2;
        }
    }
 
    LOG("Update netting set KVA done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateNettingSetCvaSensitivity()

void updateNettingSetCvaSensitivity ( )

protected

Definition at line 545 of file postprocess.cpp.

                                                 {
 
    if (!analytics_["cvaSensi"])
        return;
 
    LOG("Update netting set CVA sensitivities");
 
    Handle<YieldTermStructure> discountCurve = market_->discountCurve(baseCurrency_, configuration_);
 
    for (auto n : netEPE_) {
        string nettingSetId = n.first;
        vector<Real> epe = netEPE_[nettingSetId];
        string cid;
        Handle<DefaultProbabilityTermStructure> cvaDts;
        Real cvaRR;
        if (analytics_["flipViewXVA"]) {
            cid = dvaName_;
        } else {
            cid = nettedExposureCalculator_->counterparty(nettingSetId);
        }
        cvaDts = market_->defaultCurve(cid)->curve();
        QL_REQUIRE(!cvaDts.empty(), "Default curve missing for counterparty " << cid);
        cvaRR = market_->recoveryRate(cid, configuration_)->value();
 
        bool cvaSensi = analytics_["cvaSensi"];
        LOG("CVA Sensitivity: " << cvaSensi);
        if (cvaSensi) {
            QuantLib::ext::shared_ptr<CVASpreadSensitivityCalculator> cvaSensiCalculator = QuantLib::ext::make_shared<CVASpreadSensitivityCalculator>(
                 nettingSetId, market_->asofDate(), epe, cube_->dates(), cvaDts, cvaRR, discountCurve, cvaSpreadSensiGrid_, cvaSpreadSensiShiftSize_);
 
            for (Size i = 0; i < cvaSensiCalculator->shiftTimes().size(); ++i) {
                DLOG("CVA Sensi Calculator: t=" << cvaSensiCalculator->shiftTimes()[i]
                 << " h=" << cvaSensiCalculator->hazardRateSensitivities()[i] 
                 << " s=" << cvaSensiCalculator->cdsSpreadSensitivities()[i]); 
            }
 
            netCvaHazardRateSensi_[nettingSetId] = cvaSensiCalculator->hazardRateSensitivities();
            netCvaSpreadSensi_[nettingSetId] = cvaSensiCalculator->cdsSpreadSensitivities();
            cvaSpreadSensiTimes_ = cvaSensiCalculator->shiftTimes();
        } else {
            cvaSpreadSensiTimes_ = vector<Real>();
            netCvaHazardRateSensi_[nettingSetId] = vector<Real>();
            netCvaSpreadSensi_[nettingSetId] = vector<Real>();
        }
    }
 
    LOG("Update netting set CVA sensitivities done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ portfolio_

QuantLib::ext::shared_ptr<Portfolio> portfolio_

protected

Definition at line 330 of file postprocess.hpp.

◆ nettingSetManager_

QuantLib::ext::shared_ptr<NettingSetManager> nettingSetManager_

protected

Definition at line 331 of file postprocess.hpp.

◆ collateralBalances_

QuantLib::ext::shared_ptr<CollateralBalances> collateralBalances_

protected

Definition at line 332 of file postprocess.hpp.

◆ market_

QuantLib::ext::shared_ptr<Market> market_

protected

Definition at line 333 of file postprocess.hpp.

◆ configuration_

const std::string configuration_

protected

Definition at line 334 of file postprocess.hpp.

◆ cube_

QuantLib::ext::shared_ptr<NPVCube> cube_

protected

Definition at line 335 of file postprocess.hpp.

◆ cptyCube_

QuantLib::ext::shared_ptr<NPVCube> cptyCube_

protected

Definition at line 336 of file postprocess.hpp.

◆ scenarioData_

QuantLib::ext::shared_ptr<AggregationScenarioData> scenarioData_

protected

Definition at line 337 of file postprocess.hpp.

◆ analytics_

map<string, bool> analytics_

protected

Definition at line 338 of file postprocess.hpp.

◆ tradeEPE_

map<string, vector<Real> > tradeEPE_

protected

Definition at line 340 of file postprocess.hpp.

◆ tradeENE_

map<string, vector<Real> > tradeENE_

protected

Definition at line 340 of file postprocess.hpp.

◆ allocatedTradeEPE_

map<string, vector<Real> > allocatedTradeEPE_

protected

Definition at line 341 of file postprocess.hpp.

◆ allocatedTradeENE_

map<string, vector<Real> > allocatedTradeENE_

protected

Definition at line 341 of file postprocess.hpp.

◆ netEPE_

map<string, vector<Real> > netEPE_

protected

Definition at line 342 of file postprocess.hpp.

◆ netENE_

map<string, vector<Real> > netENE_

protected

Definition at line 342 of file postprocess.hpp.

◆ ourNettingSetKVACCR_

map<string, Real> ourNettingSetKVACCR_

protected

Definition at line 343 of file postprocess.hpp.

◆ theirNettingSetKVACCR_

map<string, Real> theirNettingSetKVACCR_

protected

Definition at line 343 of file postprocess.hpp.

◆ ourNettingSetKVACVA_

map<string, Real> ourNettingSetKVACVA_

protected

Definition at line 343 of file postprocess.hpp.

◆ theirNettingSetKVACVA_

map<string, Real> theirNettingSetKVACVA_

protected

Definition at line 343 of file postprocess.hpp.

◆ netCvaSpreadSensi_

map<string, vector<Real> > netCvaSpreadSensi_

protected

Definition at line 344 of file postprocess.hpp.

◆ netCvaHazardRateSensi_

map<string, vector<Real> > netCvaHazardRateSensi_

protected

Definition at line 344 of file postprocess.hpp.

◆ baseCurrency_

string baseCurrency_

protected

Definition at line 348 of file postprocess.hpp.

◆ quantile_

Real quantile_

protected

Definition at line 349 of file postprocess.hpp.

◆ calcType_

CollateralExposureHelper::CalculationType calcType_

protected

Definition at line 350 of file postprocess.hpp.

◆ dvaName_

string dvaName_

protected

Definition at line 351 of file postprocess.hpp.

◆ fvaBorrowingCurve_

string fvaBorrowingCurve_

protected

Definition at line 352 of file postprocess.hpp.

◆ fvaLendingCurve_

string fvaLendingCurve_

protected

Definition at line 353 of file postprocess.hpp.

◆ dimCalculator_

QuantLib::ext::shared_ptr<DynamicInitialMarginCalculator> dimCalculator_

protected

Definition at line 355 of file postprocess.hpp.

◆ exposureCalculator_

QuantLib::ext::shared_ptr<ExposureCalculator> exposureCalculator_

protected

Definition at line 356 of file postprocess.hpp.

◆ nettedExposureCalculator_

QuantLib::ext::shared_ptr<NettedExposureCalculator> nettedExposureCalculator_

protected

Definition at line 357 of file postprocess.hpp.

◆ cvaCalculator_

QuantLib::ext::shared_ptr<ValueAdjustmentCalculator> cvaCalculator_

protected

Definition at line 358 of file postprocess.hpp.

◆ allocatedCvaCalculator_

QuantLib::ext::shared_ptr<ValueAdjustmentCalculator> allocatedCvaCalculator_

protected

Definition at line 359 of file postprocess.hpp.

◆ cubeInterpretation_

QuantLib::ext::shared_ptr<CubeInterpretation> cubeInterpretation_

protected

Definition at line 360 of file postprocess.hpp.

◆ fullInitialCollateralisation_

bool fullInitialCollateralisation_

protected

Definition at line 361 of file postprocess.hpp.

◆ cvaSpreadSensiGrid_

vector<Period> cvaSpreadSensiGrid_

protected

Definition at line 362 of file postprocess.hpp.

◆ cvaSpreadSensiTimes_

vector<Time> cvaSpreadSensiTimes_

protected

Definition at line 363 of file postprocess.hpp.

◆ cvaSpreadSensiShiftSize_

Real cvaSpreadSensiShiftSize_

protected

Definition at line 364 of file postprocess.hpp.

◆ kvaCapitalDiscountRate_

Real kvaCapitalDiscountRate_

protected

Definition at line 365 of file postprocess.hpp.

◆ kvaAlpha_

Real kvaAlpha_

protected

Definition at line 366 of file postprocess.hpp.

◆ kvaRegAdjustment_

Real kvaRegAdjustment_

protected

Definition at line 367 of file postprocess.hpp.

◆ kvaCapitalHurdle_

Real kvaCapitalHurdle_

protected

Definition at line 368 of file postprocess.hpp.

◆ kvaOurPdFloor_

Real kvaOurPdFloor_

protected

Definition at line 369 of file postprocess.hpp.

◆ kvaTheirPdFloor_

Real kvaTheirPdFloor_

protected

Definition at line 370 of file postprocess.hpp.

◆ kvaOurCvaRiskWeight_

Real kvaOurCvaRiskWeight_

protected

Definition at line 371 of file postprocess.hpp.

◆ kvaTheirCvaRiskWeight_

Real kvaTheirCvaRiskWeight_

protected

Definition at line 372 of file postprocess.hpp.

◆ creditSimulationParameters_

QuantLib::ext::shared_ptr<CreditSimulationParameters> creditSimulationParameters_

protected

Definition at line 374 of file postprocess.hpp.

◆ creditMigrationDistributionGrid_

std::vector<Real> creditMigrationDistributionGrid_

protected

Definition at line 375 of file postprocess.hpp.

◆ creditMigrationTimeSteps_

std::vector<Size> creditMigrationTimeSteps_

protected

Definition at line 376 of file postprocess.hpp.

◆ creditStateCorrelationMatrix_

Matrix creditStateCorrelationMatrix_

protected

Definition at line 377 of file postprocess.hpp.

◆ creditMigrationCalculator_

QuantLib::ext::shared_ptr<CreditMigrationCalculator> creditMigrationCalculator_

protected

Definition at line 378 of file postprocess.hpp.

◆ creditMigrationUpperBucketBounds_

std::vector<Real> creditMigrationUpperBucketBounds_

protected

Definition at line 379 of file postprocess.hpp.

◆ creditMigrationCdf_

std::vector<std::vector<Real> > creditMigrationCdf_

protected

Definition at line 380 of file postprocess.hpp.

◆ creditMigrationPdf_

std::vector<std::vector<Real> > creditMigrationPdf_

protected

Definition at line 381 of file postprocess.hpp.

◆ withMporStickyDate_

bool withMporStickyDate_

protected

Definition at line 382 of file postprocess.hpp.

◆ mporCashFlowMode_

MporCashFlowMode mporCashFlowMode_

protected

Definition at line 383 of file postprocess.hpp.

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PostProcess()

Member Function Documentation

◆ setDimCalculator()

◆ spreadSensitivityTimes()

◆ spreadSensitivityGrid()

◆ tradeIds()

◆ nettingSetIds()

◆ counterpartyId()

◆ tradeEPE()

◆ tradeENE()

◆ tradeEE_B()

◆ tradeEPE_B()

◆ tradeEEE_B()

◆ tradeEEPE_B()

◆ tradePFE()

◆ netEPE()

◆ netENE()

◆ netEE_B()

◆ netEPE_B()

◆ netEEE_B()

◆ netEEPE_B()

◆ netPFE()

◆ expectedCollateral()

◆ colvaIncrements()

◆ collateralFloorIncrements()

◆ allocatedTradeEPE()

◆ allocatedTradeENE()

◆ netCvaHazardRateSensitivity()

◆ netCvaSpreadSensitivity() [1/2]

◆ netCvaSpreadSensitivity() [2/2]

◆ tradeCVA()

◆ tradeDVA()

◆ tradeMVA()

◆ tradeFBA()

◆ tradeFCA()

◆ tradeFBA_exOwnSP()

◆ tradeFCA_exOwnSP()

◆ tradeFBA_exAllSP()

◆ tradeFCA_exAllSP()

◆ allocatedTradeCVA()

◆ allocatedTradeDVA()

◆ nettingSetCVA()

◆ nettingSetDVA()

◆ nettingSetMVA()

◆ nettingSetFBA()

◆ nettingSetFCA()

◆ nettingSetOurKVACCR()

◆ nettingSetTheirKVACCR()

◆ nettingSetOurKVACVA()

◆ nettingSetTheirKVACVA()

◆ nettingSetFBA_exOwnSP()

◆ nettingSetFCA_exOwnSP()

◆ nettingSetFBA_exAllSP()

◆ nettingSetFCA_exAllSP()

◆ nettingSetCOLVA()

◆ nettingSetCollateralFloor()

◆ cube()

◆ cptyCube()

◆ netCube()

◆ exportDimEvolution()

◆ exportDimRegression()

◆ cvaSpreadSensiShiftSize()

◆ creditMigrationUpperBucketBounds()

◆ creditMigrationCdf()

◆ creditMigrationPdf()

◆ collateralPaths()

◆ updateNettingSetKVA()

◆ updateNettingSetCvaSensitivity()

Member Data Documentation

◆ portfolio_

◆ nettingSetManager_

◆ collateralBalances_

◆ market_

◆ configuration_

◆ cube_