XVA Calculator base class. More...

#include <orea/aggregation/exposurecalculator.hpp>

Collaboration diagram for ExposureCalculator:

Public Types
enum	ExposureIndex { EPE = 0 , ENE , allocatedEPE , allocatedENE }

Public Member Functions
	ExposureCalculator (const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< NPVCube > &cube, const QuantLib::ext::shared_ptr< CubeInterpretation > cubeInterpretation, const QuantLib::ext::shared_ptr< Market > &market, const bool exerciseNextBreak, const string &baseCurrency, const string &configuration, const Real quantile, const CollateralExposureHelper::CalculationType calcType, const bool multiPath, const bool flipViewXVA)

virtual	~ExposureCalculator ()

virtual void	build ()
	Compute exposures along all paths and fill result structures. More...

QuantLib::ext::shared_ptr< Portfolio >	portfolio ()

QuantLib::ext::shared_ptr< NPVCube >	npvCube ()

QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpretation ()

QuantLib::ext::shared_ptr< Market >	market ()

bool	exerciseNextBreak ()

string	baseCurrency ()

string	configuration ()

Real	quantile ()

CollateralExposureHelper::CalculationType	calcType ()

bool	isRegularCubeStorage ()

bool	multiPath ()

vector< Date >	dates ()

Date	today ()

DayCounter	dc ()

vector< string >	nettingSetIds ()

map< string, Real >	nettingSetValueToday ()

map< string, Date >	nettingSetMaturity ()

vector< Real >	times ()

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

const map< string, vector< vector< Real > > > &	nettingSetDefaultValue ()

const map< string, vector< vector< Real > > > &	nettingSetCloseOutValue ()

const map< string, vector< vector< Real > > > &	nettingSetMporPositiveFlow ()

const map< string, vector< vector< Real > > > &	nettingSetMporNegativeFlow ()

vector< Real >	epe (const string &tid)

vector< Real >	ene (const string &tid)

vector< Real >	allocatedEpe (const string &tid)

vector< Real >	allocatedEne (const string &tid)

vector< Real > &	ee_b (const string &tid)

vector< Real > &	eee_b (const string &tid)

vector< Real > &	pfe (const string &tid)

Real &	epe_b (const string &tid)

Real &	eepe_b (const string &tid)

Public Attributes
const Size	EXPOSURE_CUBE_DEPTH = 4

Protected Member Functions
vector< Real >	getMeanExposure (const string &tid, ExposureIndex index)

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

const QuantLib::ext::shared_ptr< NPVCube >	cube_

const QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpretation_

const QuantLib::ext::shared_ptr< Market >	market_

const bool	exerciseNextBreak_

const string	baseCurrency_

const string	configuration_

const Real	quantile_

const CollateralExposureHelper::CalculationType	calcType_

const bool	multiPath_

bool	isRegularCubeStorage_

vector< Date >	dates_

const Date	today_

const DayCounter	dc_

vector< string >	nettingSetIds_

map< string, Real >	nettingSetValueToday_

map< string, Date >	nettingSetMaturity_

vector< Real >	times_

QuantLib::ext::shared_ptr< NPVCube >	exposureCube_

map< string, vector< vector< Real > > >	nettingSetDefaultValue_

map< string, vector< vector< Real > > >	nettingSetCloseOutValue_

map< string, vector< vector< Real > > >	nettingSetMporPositiveFlow_

map< string, vector< vector< Real > > >	nettingSetMporNegativeFlow_

map< string, std::vector< Real > >	ee_b_

map< string, std::vector< Real > >	eee_b_

map< string, std::vector< Real > >	pfe_

map< string, Real >	epe_b_

map< string, Real >	eepe_b_

bool	flipViewXVA_

Detailed Description

XVA Calculator base class.

Derived classes implement a constructor with the relevant additional input data and a build function that performs the XVA calculations for all netting sets and along all paths.

Definition at line 46 of file exposurecalculator.hpp.

Member Enumeration Documentation

◆ ExposureIndex

enum ExposureIndex

Enumerator
EPE
ENE
allocatedEPE
allocatedENE

Definition at line 78 of file exposurecalculator.hpp.

                       {
        EPE = 0,
        ENE,
        allocatedEPE,
        allocatedENE
    };

Constructor & Destructor Documentation

◆ ExposureCalculator()

ExposureCalculator	(	const QuantLib::ext::shared_ptr< Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< NPVCube > &	cube,
		const QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpretation,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const bool	exerciseNextBreak,
		const string &	baseCurrency,
		const string &	configuration,
		const Real	quantile,
		const CollateralExposureHelper::CalculationType	calcType,
		const bool	multiPath,
		const bool	flipViewXVA
	)

Parameters

portfolio	Driving portfolio consistent with the cube below
cube	NPV cube resulting from the Monte Carlo simulation loop
cubeInterpretation	Interpreter for cube storage (where to find which data items)
market	Market data object to access e.g. discounting and funding curves
exerciseNextBreak	Flag to indicate exposure termination at the next break date
baseCurrency	Expression currency for all results
configuration	Market configuration to use
quantile	Quantile for Potential Future Exposure output
calcType	Collateral calculation type to be used, see class CollateralExposureHelper
multiPath	Flag to indicate exposure evaluation with dynamic credit
flipViewXVA	Flag to indicate flipped xva calculation

Definition at line 33 of file exposurecalculator.cpp.

    : portfolio_(portfolio), cube_(cube), cubeInterpretation_(cubeInterpretation),
       market_(market), exerciseNextBreak_(exerciseNextBreak),
      baseCurrency_(baseCurrency), configuration_(configuration),
      quantile_(quantile), calcType_(calcType),
      multiPath_(multiPath), dates_(cube->dates()),
      today_(market_->asofDate()), dc_(ActualActual(ActualActual::ISDA)), flipViewXVA_(flipViewXVA) {
 
    QL_REQUIRE(portfolio_, "portfolio is null");
 
    if (multiPath) {
        exposureCube_ = QuantLib::ext::make_shared<SinglePrecisionInMemoryCubeN>(
            market->asofDate(), portfolio_->ids(), dates_,
            cube_->samples(), EXPOSURE_CUBE_DEPTH);// EPE, ENE, allocatedEPE, allocatedENE
    } else {
        exposureCube_ = QuantLib::ext::make_shared<DoublePrecisionInMemoryCubeN>(
            market->asofDate(), portfolio_->ids(), dates_,
            1, EXPOSURE_CUBE_DEPTH);// EPE, ENE, allocatedEPE, allocatedENE
    }
 
    set<string> nettingSetIdsSet;
    for (const auto& [tradeId, trade] : portfolio->trades())
        nettingSetIdsSet.insert(trade->envelope().nettingSetId());
    nettingSetIds_= vector<string>(nettingSetIdsSet.begin(), nettingSetIdsSet.end());
 
    times_ = vector<Real>(dates_.size(), 0.0);
    for (Size i = 0; i < dates_.size(); i++)
        times_[i] = dc_.yearFraction(today_, cube_->dates()[i]);
 
    isRegularCubeStorage_ = !cubeInterpretation_->withCloseOutLag();
}

Here is the call graph for this function:

◆ ~ExposureCalculator()

virtual ~ExposureCalculator ( )

virtual

Definition at line 73 of file exposurecalculator.hpp.

73{}

Member Function Documentation

◆ build()

void build ( )

virtual

Compute exposures along all paths and fill result structures.

Definition at line 71 of file exposurecalculator.cpp.

                               {
    LOG("Compute trade exposure profiles, " << (flipViewXVA_ ? "inverted (flipViewXVA = Y)" : "regular (flipViewXVA = N)"));
    size_t i = 0;
    for (auto tradeIt = portfolio_->trades().begin(); tradeIt != portfolio_->trades().end(); ++tradeIt, ++i) {
        auto trade = tradeIt->second;
        string tradeId = tradeIt->first;
        string nettingSetId = trade->envelope().nettingSetId();
        LOG("Aggregate exposure for trade " << tradeId);
        if (nettingSetDefaultValue_.find(nettingSetId) == nettingSetDefaultValue_.end()) {
            nettingSetDefaultValue_[nettingSetId] = vector<vector<Real>>(dates_.size(), vector<Real>(cube_->samples(), 0.0));
            nettingSetCloseOutValue_[nettingSetId] = vector<vector<Real>>(dates_.size(), vector<Real>(cube_->samples(), 0.0));
            nettingSetMporPositiveFlow_[nettingSetId] = vector<vector<Real>>(dates_.size(), vector<Real>(cube_->samples(), 0.0));
            nettingSetMporNegativeFlow_[nettingSetId] = vector<vector<Real>>(dates_.size(), vector<Real>(cube_->samples(), 0.0));
        }
 
        // Identify the next break date if provided, default is trade maturity.
        Date nextBreakDate = trade->maturity();
        TradeActions ta = trade->tradeActions();
        if (exerciseNextBreak_ && !ta.empty()) {
            // loop over actions and pick next mutual break, if available
            vector<TradeAction> actions = ta.actions();
            for (Size j = 0; j < actions.size(); ++j) {
                DLOG("TradeAction for " << tradeId << ", actionType " << actions[j].type() << ", actionOwner "
                                        << actions[j].owner());
                // FIXME: Introduce enumeration and parse text when building trade
                if (actions[j].type() == "Break" && actions[j].owner() == "Mutual") {
                    QuantLib::Schedule schedule = ore::data::makeSchedule(actions[j].schedule());
                    vector<Date> dates = schedule.dates();
                    std::sort(dates.begin(), dates.end());
                    Date today = Settings::instance().evaluationDate();
                    for (Size k = 0; k < dates.size(); ++k) {
                        if (dates[k] > today && dates[k] < nextBreakDate) {
                            nextBreakDate = dates[k];
                            DLOG("Next break date for trade " << tradeId << ": "
                                                              << QuantLib::io::iso_date(nextBreakDate));
                            break;
                        }
                    }
                }
            }
        }
 
        Handle<YieldTermStructure> curve = market_->discountCurve(baseCurrency_, configuration_);
        Real npv0;
        if (flipViewXVA_) {
            npv0 = -cube_->getT0(i);
        } else {
            npv0 = cube_->getT0(i);
        }
        vector<Real> epe(dates_.size() + 1, 0.0);
        vector<Real> ene(dates_.size() + 1, 0.0);
        vector<Real> ee_b(dates_.size() + 1, 0.0);
        vector<Real> eee_b(dates_.size() + 1, 0.0);
        vector<Real> pfe(dates_.size() + 1, 0.0);
        epe[0] = std::max(npv0, 0.0);
        ene[0] = std::max(-npv0, 0.0);
        ee_b[0] = epe[0];
        eee_b[0] = ee_b[0];
        pfe[0] = std::max(npv0, 0.0);
        exposureCube_->setT0(epe[0], tradeId, ExposureIndex::EPE);
        exposureCube_->setT0(ene[0], tradeId, ExposureIndex::ENE);
        for (Size j = 0; j < dates_.size(); ++j) {
            Date d = cube_->dates()[j];
            vector<Real> distribution(cube_->samples(), 0.0);
            for (Size k = 0; k < cube_->samples(); ++k) {
                // RL 2020-07-17
                // 1) If the calculation type is set to NoLag:
                //    Collateral balances are NOT delayed by the MPoR, but we use the close-out NPV.
                // 2) Otherwise:
                //    Collateral balances are delayed by the MPoR (if possible, i.e. the valuation
                //    grid has MPoR spacing), and we use the default date NPV.
                //    This is the treatment in the ORE releases up to June 2020).
                Real defaultValue =
                    d > nextBreakDate && exerciseNextBreak_ ? 0.0 : cubeInterpretation_->getDefaultNpv(cube_, i, j, k);
                Real closeOutValue;
                if (isRegularCubeStorage_ && j == dates_.size() - 1)
                    closeOutValue = defaultValue;
                else
                    closeOutValue = d > nextBreakDate && exerciseNextBreak_
                                        ? 0.0
                                        : cubeInterpretation_->getCloseOutNpv(cube_, i, j, k);
 
                Real positiveCashFlow = cubeInterpretation_->getMporPositiveFlows(cube_, i, j, k);
                Real negativeCashFlow = cubeInterpretation_->getMporNegativeFlows(cube_, i, j, k);
                //for single trade exposures, always default value is relevant
                Real npv = defaultValue;
                epe[j + 1] += max(npv, 0.0) / cube_->samples();
                ene[j + 1] += max(-npv, 0.0) / cube_->samples();
                nettingSetDefaultValue_[nettingSetId][j][k] += defaultValue;
                nettingSetCloseOutValue_[nettingSetId][j][k] += closeOutValue;
                nettingSetMporPositiveFlow_[nettingSetId][j][k] += positiveCashFlow;
                nettingSetMporNegativeFlow_[nettingSetId][j][k] += negativeCashFlow;
                distribution[k] = npv;
                if (multiPath_) {
                    exposureCube_->set(max(npv, 0.0), tradeId, d, k, ExposureIndex::EPE);
                    exposureCube_->set(max(-npv, 0.0), tradeId, d, k, ExposureIndex::ENE);
                }
            }
            if (!multiPath_) {
                exposureCube_->set(epe[j + 1], tradeId, d, 0, ExposureIndex::EPE);
                exposureCube_->set(ene[j + 1], tradeId, d, 0, ExposureIndex::ENE);
            }
            ee_b[j + 1] = epe[j + 1] / curve->discount(cube_->dates()[j]);
            eee_b[j + 1] = std::max(eee_b[j], ee_b[j + 1]);
            std::sort(distribution.begin(), distribution.end());
            Size index = Size(floor(quantile_ * (cube_->samples() - 1) + 0.5));
            pfe[j + 1] = std::max(distribution[index], 0.0);
        }
        ee_b_[tradeId] = ee_b;
        eee_b_[tradeId] = eee_b;
        pfe_[tradeId] = pfe;
 
        Real epe_b = 0.0;
        Real eepe_b = 0.0;
 
        Size t = 0;
        Calendar cal = WeekendsOnly();
        /*The time average in the EEPE calculation is taken over the first year of the exposure evolution
        (or until maturity if all positions of the netting set mature before one year).
        This one year point is actually taken to be today+1Y+4D, so that the 1Y point on the dateGrid is always
        included.
        This may effect DateGrids with daily data points*/
        Date maturity = std::min(cal.adjust(today_ + 1 * Years + 4 * Days), trade->maturity());
        QuantLib::Real maturityTime = dc_.yearFraction(today_, maturity);
 
        while (t < dates_.size() && times_[t] <= maturityTime)
            ++t;
 
        if (t > 0) {
            vector<double> weights(t);
            weights[0] = times_[0];
            for (Size k = 1; k < t; k++)
                weights[k] = times_[k] - times_[k - 1];
            double totalWeights = std::accumulate(weights.begin(), weights.end(), 0.0);
            for (Size k = 0; k < t; k++)
                weights[k] /= totalWeights;
 
            for (Size k = 0; k < t; k++) {
                epe_b += ee_b[k] * weights[k];
                eepe_b += eee_b[k] * weights[k];
            }
        }
        epe_b_[tradeId] = epe_b;
        eepe_b_[tradeId] = eepe_b;
    }
}

Here is the call graph for this function:

◆ portfolio()

QuantLib::ext::shared_ptr< Portfolio > portfolio ( )

Definition at line 86 of file exposurecalculator.hpp.

86{ return portfolio_; }

Here is the caller graph for this function:

◆ npvCube()

QuantLib::ext::shared_ptr< NPVCube > npvCube ( )

Definition at line 87 of file exposurecalculator.hpp.

87{ return cube_; }

◆ cubeInterpretation()

QuantLib::ext::shared_ptr< CubeInterpretation > cubeInterpretation ( )

Definition at line 88 of file exposurecalculator.hpp.

88{ return cubeInterpretation_; }

◆ market()

QuantLib::ext::shared_ptr< Market > market ( )

Definition at line 89 of file exposurecalculator.hpp.

89{ return market_; }

Here is the caller graph for this function:

◆ exerciseNextBreak()

bool exerciseNextBreak ( )

Definition at line 90 of file exposurecalculator.hpp.

90{ return exerciseNextBreak_; }

◆ baseCurrency()

string baseCurrency ( )

Definition at line 91 of file exposurecalculator.hpp.

91{ return baseCurrency_; }

◆ configuration()

string configuration ( )

Definition at line 92 of file exposurecalculator.hpp.

92{ return configuration_; }

◆ quantile()

Real quantile ( )

Definition at line 93 of file exposurecalculator.hpp.

93{ return quantile_; }

◆ calcType()

CollateralExposureHelper::CalculationType calcType ( )

Definition at line 94 of file exposurecalculator.hpp.

94{ return calcType_; }

◆ isRegularCubeStorage()

bool isRegularCubeStorage ( )

Definition at line 95 of file exposurecalculator.hpp.

95{ return isRegularCubeStorage_; }

◆ multiPath()

bool multiPath ( )

Definition at line 96 of file exposurecalculator.hpp.

96{ return multiPath_; }

Here is the caller graph for this function:

◆ dates()

vector< Date > dates ( )

Definition at line 98 of file exposurecalculator.hpp.

98{ return dates_; }

Here is the caller graph for this function:

◆ today()

Date today ( )

Definition at line 99 of file exposurecalculator.hpp.

99{ return today_; }

Here is the caller graph for this function:

◆ dc()

DayCounter dc ( )

Definition at line 100 of file exposurecalculator.hpp.

100{ return dc_; }

◆ nettingSetIds()

vector< string > nettingSetIds ( )

Definition at line 101 of file exposurecalculator.hpp.

101{ return nettingSetIds_; }

◆ nettingSetValueToday()

map< string, Real > nettingSetValueToday ( )

Definition at line 102 of file exposurecalculator.hpp.

102{ return nettingSetValueToday_; }

ore::analytics::ExposureCalculator::nettingSetValueToday_

map< string, Real > nettingSetValueToday_

Definition: exposurecalculator.hpp:139

◆ nettingSetMaturity()

map< string, Date > nettingSetMaturity ( )

Definition at line 103 of file exposurecalculator.hpp.

103{ return nettingSetMaturity_; }

ore::analytics::ExposureCalculator::nettingSetMaturity_

map< string, Date > nettingSetMaturity_

Definition: exposurecalculator.hpp:140

◆ times()

vector< Real > times ( )

Definition at line 104 of file exposurecalculator.hpp.

104{ return times_; };

◆ exposureCube()

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

Definition at line 106 of file exposurecalculator.hpp.

106{ return exposureCube_; }

◆ nettingSetDefaultValue()

const map< string, vector< vector< Real > > > & nettingSetDefaultValue ( )

Definition at line 107 of file exposurecalculator.hpp.

107{ return nettingSetDefaultValue_; }

◆ nettingSetCloseOutValue()

const map< string, vector< vector< Real > > > & nettingSetCloseOutValue ( )

Definition at line 108 of file exposurecalculator.hpp.

108{ return nettingSetCloseOutValue_; }

◆ nettingSetMporPositiveFlow()

const map< string, vector< vector< Real > > > & nettingSetMporPositiveFlow ( )

Definition at line 109 of file exposurecalculator.hpp.

109{ return nettingSetMporPositiveFlow_; }

◆ nettingSetMporNegativeFlow()

const map< string, vector< vector< Real > > > & nettingSetMporNegativeFlow ( )

Definition at line 110 of file exposurecalculator.hpp.

110{ return nettingSetMporNegativeFlow_; }

◆ epe()

vector< Real > epe ( const string & tid )

Definition at line 112 of file exposurecalculator.hpp.

112{ return getMeanExposure(tid, ExposureIndex::EPE); }

ore::analytics::ExposureCalculator::getMeanExposure

vector< Real > getMeanExposure(const string &tid, ExposureIndex index)

Definition: exposurecalculator.cpp:218

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ene()

vector< Real > ene ( const string & tid )

Definition at line 113 of file exposurecalculator.hpp.

113{ return getMeanExposure(tid, ExposureIndex::ENE); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allocatedEpe()

vector< Real > allocatedEpe ( const string & tid )

Definition at line 114 of file exposurecalculator.hpp.

114{ return getMeanExposure(tid, ExposureIndex::allocatedEPE); }

Here is the call graph for this function:

◆ allocatedEne()

vector< Real > allocatedEne ( const string & tid )

Definition at line 115 of file exposurecalculator.hpp.

115{ return getMeanExposure(tid, ExposureIndex::allocatedENE); }

Here is the call graph for this function:

◆ ee_b()

vector< Real > & ee_b ( const string & tid )

Definition at line 116 of file exposurecalculator.hpp.

116{ return ee_b_[tid]; }

Here is the caller graph for this function:

◆ eee_b()

vector< Real > & eee_b ( const string & tid )

Definition at line 117 of file exposurecalculator.hpp.

117{ return eee_b_[tid]; }

Here is the caller graph for this function:

◆ pfe()

vector< Real > & pfe ( const string & tid )

Definition at line 118 of file exposurecalculator.hpp.

118{ return pfe_[tid]; }

Here is the caller graph for this function:

◆ epe_b()

Real & epe_b ( const string & tid )

Definition at line 119 of file exposurecalculator.hpp.

119{ return epe_b_[tid]; }

Here is the caller graph for this function:

◆ eepe_b()

Real & eepe_b ( const string & tid )

Definition at line 120 of file exposurecalculator.hpp.

120{ return eepe_b_[tid]; }

Here is the caller graph for this function:

◆ getMeanExposure()

vector< Real > getMeanExposure	(	const string &	tid,
		ExposureIndex	index
	)

protected

Definition at line 218 of file exposurecalculator.cpp.

                                                                                       {
    vector<Real> exp(dates_.size() + 1, 0.0);
    exp[0] = exposureCube_->getT0(tid, index);
    for (Size i = 0; i < dates_.size(); i++) {
        for (Size k = 0; k < exposureCube_->samples(); k++) {
            exp[i + 1] += exposureCube_->get(tid, dates_[i], k, index);
        }
        exp[i + 1] /= exposureCube_->samples();
    }
    return exp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ EXPOSURE_CUBE_DEPTH

const Size EXPOSURE_CUBE_DEPTH = 4

Definition at line 84 of file exposurecalculator.hpp.

◆ portfolio_

const QuantLib::ext::shared_ptr<Portfolio> portfolio_

protected

Definition at line 123 of file exposurecalculator.hpp.

◆ cube_

const QuantLib::ext::shared_ptr<NPVCube> cube_

protected

Definition at line 124 of file exposurecalculator.hpp.

◆ cubeInterpretation_

const QuantLib::ext::shared_ptr<CubeInterpretation> cubeInterpretation_

protected

Definition at line 125 of file exposurecalculator.hpp.

◆ market_

const QuantLib::ext::shared_ptr<Market> market_

protected

Definition at line 126 of file exposurecalculator.hpp.

◆ exerciseNextBreak_

const bool exerciseNextBreak_

protected

Definition at line 127 of file exposurecalculator.hpp.

◆ baseCurrency_

const string baseCurrency_

protected

Definition at line 128 of file exposurecalculator.hpp.

◆ configuration_

const string configuration_

protected

Definition at line 129 of file exposurecalculator.hpp.

◆ quantile_

const Real quantile_

protected

Definition at line 130 of file exposurecalculator.hpp.

◆ calcType_

const CollateralExposureHelper::CalculationType calcType_

protected

Definition at line 131 of file exposurecalculator.hpp.

◆ multiPath_

const bool multiPath_

protected

Definition at line 132 of file exposurecalculator.hpp.

◆ isRegularCubeStorage_

bool isRegularCubeStorage_

protected

Definition at line 133 of file exposurecalculator.hpp.

◆ dates_

vector<Date> dates_

protected

Definition at line 135 of file exposurecalculator.hpp.

◆ today_

const Date today_

protected

Definition at line 136 of file exposurecalculator.hpp.

◆ dc_

const DayCounter dc_

protected

Definition at line 137 of file exposurecalculator.hpp.

◆ nettingSetIds_

vector<string> nettingSetIds_

protected

Definition at line 138 of file exposurecalculator.hpp.

◆ nettingSetValueToday_

map<string, Real> nettingSetValueToday_

protected

Definition at line 139 of file exposurecalculator.hpp.

◆ nettingSetMaturity_

map<string, Date> nettingSetMaturity_

protected

Definition at line 140 of file exposurecalculator.hpp.

◆ times_

vector<Real> times_

protected

Definition at line 141 of file exposurecalculator.hpp.

◆ exposureCube_

QuantLib::ext::shared_ptr<NPVCube> exposureCube_

protected

Definition at line 143 of file exposurecalculator.hpp.

◆ nettingSetDefaultValue_

map<string, vector<vector<Real> > > nettingSetDefaultValue_

protected

Definition at line 144 of file exposurecalculator.hpp.

◆ nettingSetCloseOutValue_

map<string, vector<vector<Real> > > nettingSetCloseOutValue_

protected

Definition at line 144 of file exposurecalculator.hpp.

◆ nettingSetMporPositiveFlow_

map<string, vector<vector<Real> > > nettingSetMporPositiveFlow_

protected

Definition at line 145 of file exposurecalculator.hpp.

◆ nettingSetMporNegativeFlow_

map<string, vector<vector<Real> > > nettingSetMporNegativeFlow_

protected

Definition at line 145 of file exposurecalculator.hpp.

◆ ee_b_

map<string, std::vector<Real> > ee_b_

protected

Definition at line 147 of file exposurecalculator.hpp.

◆ eee_b_

map<string, std::vector<Real> > eee_b_

protected

Definition at line 148 of file exposurecalculator.hpp.

◆ pfe_

map<string, std::vector<Real> > pfe_

protected

Definition at line 149 of file exposurecalculator.hpp.

◆ epe_b_

map<string, Real> epe_b_

protected

Definition at line 150 of file exposurecalculator.hpp.

◆ eepe_b_

map<string, Real> eepe_b_

protected

Definition at line 151 of file exposurecalculator.hpp.

◆ flipViewXVA_

bool flipViewXVA_

protected

Definition at line 153 of file exposurecalculator.hpp.

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ ExposureIndex

Constructor & Destructor Documentation

◆ ExposureCalculator()

◆ ~ExposureCalculator()

Member Function Documentation

◆ build()

◆ portfolio()

◆ npvCube()

◆ cubeInterpretation()

◆ market()

◆ exerciseNextBreak()

◆ baseCurrency()

◆ configuration()

◆ quantile()

◆ calcType()

◆ isRegularCubeStorage()

◆ multiPath()

◆ dates()

◆ today()

◆ dc()

◆ nettingSetIds()

◆ nettingSetValueToday()

◆ nettingSetMaturity()

◆ times()

◆ exposureCube()

◆ nettingSetDefaultValue()

◆ nettingSetCloseOutValue()

◆ nettingSetMporPositiveFlow()

◆ nettingSetMporNegativeFlow()

◆ epe()

◆ ene()

◆ allocatedEpe()

◆ allocatedEne()

◆ ee_b()

◆ eee_b()

◆ pfe()

◆ epe_b()

◆ eepe_b()

◆ getMeanExposure()

Member Data Documentation

◆ EXPOSURE_CUBE_DEPTH

◆ portfolio_

◆ cube_

◆ cubeInterpretation_

◆ market_

◆ exerciseNextBreak_

◆ baseCurrency_

◆ configuration_

◆ quantile_

◆ calcType_

◆ multiPath_

◆ isRegularCubeStorage_

◆ dates_

◆ today_

◆ dc_

◆ nettingSetIds_

◆ nettingSetValueToday_

◆ nettingSetMaturity_

◆ times_

◆ exposureCube_

◆ nettingSetDefaultValue_

◆ nettingSetCloseOutValue_

◆ nettingSetMporPositiveFlow_

◆ nettingSetMporNegativeFlow_

◆ ee_b_

◆ eee_b_

◆ pfe_

◆ epe_b_

◆ eepe_b_

◆ flipViewXVA_