CreditMigrationHelper Class Reference

#include <orea/aggregation/creditmigrationhelper.hpp>

Collaboration diagram for CreditMigrationHelper:

Public Types
enum class	CreditMode { Migration , Default }
enum class	LoanExposureMode { Notional , Value }
enum class	Evaluation { Analytic , ForwardSimulationA , ForwardSimulationB , TerminalSimulation }

Public Member Functions
	CreditMigrationHelper (const QuantLib::ext::shared_ptr< CreditSimulationParameters > parameters, const QuantLib::ext::shared_ptr< NPVCube > cube, const QuantLib::ext::shared_ptr< NPVCube > nettedCube, const QuantLib::ext::shared_ptr< AggregationScenarioData > aggData, const Size cubeIndexCashflows, const Size cubeIndexStateNpvs, const Real distributionLowerBound, const Real distributionUpperBound, const Size buckets, const Matrix &globalFactorCorrelation, const std::string &baseCurrency)
void	build (const std::map< std::string, QuantLib::ext::shared_ptr< Trade > > &trades)
	builds the helper for a specific subset of trades stored in the cube More...
const std::vector< Real > &	upperBucketBound () const
Array	pnlDistribution (const Size date)

Private Member Functions
std::map< string, Matrix >	rescaledTransitionMatrices (const Size date)
void	init ()
void	initEntityStateSimulation ()
	Allocate 3d storage for the simulated idiosyncratic factors by entity, date and sample. More...
std::vector< Matrix >	initEntityStateSimulation (const Size date, const Size path)
void	simulateEntityStates (const std::vector< Matrix > &cond, const Size path, const MersenneTwisterUniformRng &mt)
Size	simulatedEntityState (const Size i, const Size path) const
	Look up the simulated entity credit state for the given entity, date and path. More...
Real	generateMigrationPnl (const Size date, const Size path, const Size n) const
void	generateConditionalMigrationPnl (const Size date, const Size path, const std::map< string, Matrix > &transMat, std::vector< Array > &condProbs, std::vector< Array > &pnl) const

Private Attributes
QuantLib::ext::shared_ptr< CreditSimulationParameters >	parameters_
QuantLib::ext::shared_ptr< NPVCube >	cube_
QuantLib::ext::shared_ptr< NPVCube >	nettedCube_
QuantLib::ext::shared_ptr< AggregationScenarioData >	aggData_
Size	cubeIndexCashflows_
Size	cubeIndexStateNpvs_
Matrix	globalFactorCorrelation_
std::string	baseCurrency_
CreditMode	creditMode_
LoanExposureMode	loanExposureMode_
Evaluation	evaluation_
std::vector< Real >	cubeTimes_
QuantExt::Bucketing	bucketing_
std::vector< std::set< std::string > >	issuerTradeIds_
std::vector< std::set< std::string > >	cptyNettingSetIds_
std::map< std::string, std::string >	tradeCreditCurves_
std::map< std::string, Real >	tradeNotionals_
std::map< std::string, std::string >	tradeCurrencies_
std::map< std::string, Size >	tradeCdsCptyIdx_
Size	n_
std::vector< std::map< string, Matrix > >	rescaledTransitionMatrices_
std::vector< Real >	globalVar_
std::vector< std::vector< Size > >	simulatedEntityState_
std::vector< std::vector< Matrix > >	entityStateSimulationMatrices_
std::vector< std::vector< std::vector< Real > > >	globalStates_

Detailed Description

Helper for credit migration risk calculation Dynamics of entity i's state X_i: \( dX_i = dY_i + dZ_i \) with

• systemic part \( dY_i = \sum_{j=1}^n \beta_{ij} dG_j \)
• n correlated global factors \( G_j \)
• entity specific factor loadings \( \beta_{ij} \)
• idiosyncratic part \( dZ_i = \sigma_i dW_i \)
• independent Wiener processes W, i.e. \( dW_k dW_l = 0 \) and \( dW_k dG_j = 0 \)

Definition at line 51 of file creditmigrationhelper.hpp.

Member Enumeration Documentation

CreditMode

enum class CreditMode

strong

Enumerator
Migration
Default

Definition at line 53 of file creditmigrationhelper.hpp.

{ Migration, Default };

LoanExposureMode

enum class LoanExposureMode

strong

Enumerator
Notional
Value

Definition at line 54 of file creditmigrationhelper.hpp.

{ Notional, Value };

Evaluation

enum class Evaluation

strong

Enumerator
Analytic
ForwardSimulationA
ForwardSimulationB
TerminalSimulation

Definition at line 55 of file creditmigrationhelper.hpp.

{ Analytic, ForwardSimulationA, ForwardSimulationB, TerminalSimulation };

Constructor & Destructor Documentation

CreditMigrationHelper()

CreditMigrationHelper	(	const QuantLib::ext::shared_ptr< CreditSimulationParameters >	parameters,
		const QuantLib::ext::shared_ptr< NPVCube >	cube,
		const QuantLib::ext::shared_ptr< NPVCube >	nettedCube,
		const QuantLib::ext::shared_ptr< AggregationScenarioData >	aggData,
		const Size	cubeIndexCashflows,
		const Size	cubeIndexStateNpvs,
		const Real	distributionLowerBound,
		const Real	distributionUpperBound,
		const Size	buckets,
		const Matrix &	globalFactorCorrelation,
		const std::string &	baseCurrency
	)

Definition at line 41 of file creditmigrationhelper.cpp.

    : parameters_(parameters), cube_(cube), nettedCube_(nettedCube), aggData_(aggData),
      cubeIndexCashflows_(cubeIndexCashflows), cubeIndexStateNpvs_(cubeIndexStateNpvs),
      globalFactorCorrelation_(globalFactorCorrelation), baseCurrency_(baseCurrency),
      creditMode_(parseCreditMode(parameters_->creditMode())),
      loanExposureMode_(parseLoanExposureMode(parameters_->loanExposureMode())),
      evaluation_(parseEvaluation(parameters_->evaluation())),
      bucketing_(distributionLowerBound, distributionUpperBound, buckets) {
 
    rescaledTransitionMatrices_.resize(cube_->numDates());
    init();
    if (evaluation_ == Evaluation::TerminalSimulation)
        initEntityStateSimulation();
} // CreditMigrationHelper()

Here is the call graph for this function:

Member Function Documentation

build()

void build

(

const std::map< std::string, QuantLib::ext::shared_ptr< Trade > > &

trades

)

builds the helper for a specific subset of trades stored in the cube

Definition at line 584 of file creditmigrationhelper.cpp.

                                                                                               {
    LOG("CreditMigrationHelper: Build trade ID map");
    issuerTradeIds_.resize(parameters_->entities().size());
    cptyNettingSetIds_.resize(parameters_->entities().size());
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        string entity = parameters_->entities()[i];
        std::set<string> tmp, tmp2;
        for (const auto& [_, t] : trades) {
            if (t->issuer() == entity) {
                tmp.insert(t->id());
            }
            if (t->envelope().counterparty() == entity &&
                std::find(parameters_->nettingSetIds().begin(), parameters_->nettingSetIds().end(),
                          t->envelope().nettingSetId()) != parameters_->nettingSetIds().end()) {
                tmp2.insert(t->envelope().nettingSetId());
            }
            QuantLib::ext::shared_ptr<Bond> bond = QuantLib::ext::dynamic_pointer_cast<Bond>(t);
            if (bond) {
                tradeCreditCurves_[t->id()] = bond->bondData().creditCurveId();
                // FIXME: We actually need the notional schedule here to determine future notionals
                tradeNotionals_[t->id()] = bond->notional();
                tradeCurrencies_[t->id()] = bond->bondData().currency();
            }
            QuantLib::ext::shared_ptr<CreditDefaultSwap> cds = QuantLib::ext::dynamic_pointer_cast<CreditDefaultSwap>(t);
            if (cds) {
                string cpty = cds->envelope().counterparty();
                QL_REQUIRE(cpty != t->issuer(), "CDS has same CPTY and issuer " << cpty);
                Size idx = std::find(parameters_->entities().begin(), parameters_->entities().end(), cpty) -
                           parameters_->entities().begin();
                if (idx < parameters_->entities().size())
                    tradeCdsCptyIdx_[t->id()] = idx;
                else
                    WLOG("CreditMigrationHelepr: CDS trade "
                         << t->id() << " has cpty " << cpty
                         << " which is not in the list of simulated entities, "
                            "ignore joint default event of issuer and cpty for this CDS");
            }
        }
        issuerTradeIds_[i] = tmp;
        cptyNettingSetIds_[i] = tmp2;
    }
    LOG("CreditMigrationHelper: Built issuer and cpty trade ID sets for " << parameters_->entities().size()
                                                                          << " entities.");
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        DLOG("Entity " << parameters_->entities()[i] << ": " << issuerTradeIds_[i].size()
                       << " trades with issuer risk, " << cptyNettingSetIds_[i].size()
                       << " nettings sets with derivative exposure risk.");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

upperBucketBound()

const std::vector< Real > & upperBucketBound

(

)

const

Definition at line 67 of file creditmigrationhelper.hpp.

{ return bucketing_.upperBucketBound(); }

Here is the call graph for this function:

Here is the caller graph for this function:

pnlDistribution()

Array pnlDistribution

(

const Size

date

)

Definition at line 447 of file creditmigrationhelper.cpp.

                                                            {
 
    // FIXME if we ask this method for more than one time step, it might be more efficient to
    // pass a vector of those time steps and compute the distirbutions in one sweep here
    // in particular step 2b-1 (in forward simulation mode)
 
    LOG("Compute PnL distribution for date " << date);
    QL_REQUIRE(date < cube_->numDates(), "date index " << date << " out of range 0..." << cube_->numDates() - 1);
    const std::vector<string>& entities = parameters_->entities();
 
    // 1 get transition matrices for entities and rescale them to horizon
 
    std::map<string, Matrix> transMat; // rescaled transition matrix per (matrix) name
 
    // 1 get transition matrices for time step and compute variance of global factors for each entiity
 
    if (parameters_->creditRisk()) {
        transMat = rescaledTransitionMatrices(date);
    }
 
    // 2 compute conditional pnl distributions and average over paths
 
    const std::set<std::string>& tradeIds = cube_->ids();
    Array res(bucketing_.buckets(), 0.0);
 
    Size numPaths = cube_->samples();
    Real avgCash = 0.0;
 
    HullWhiteBucketing hwBucketing(bucketing_.upperBucketBound().begin(), bucketing_.upperBucketBound().end());
 
    MersenneTwisterUniformRng mt(parameters_->seed());
 
    for (Size path = 0; path < numPaths; ++path) {
 
        // 2a market pnl (t0 to horizon date, over whole cube)
 
        Real cash = 0.0;
 
        if (parameters_->marketRisk()) {
            for (Size j = 0; j <= date + 1; ++j) {
                for (auto const& tradeId : tradeIds) {
                    Size i = cube_->idsAndIndexes().at(tradeId);
                    // get cumulative survival probability on the path
                    Real sp = 1.0;
                    //Real rr = 0.0;
                    // FIXME 1
                    // Methodology question: Do we need/want to multiply with the stochastic discount factor
                    // here if we do an explicit credit default simulation at horizon?
                    // FIXME 2
                    // make CDS PnL neutral bei weighting flows with surv prob and generating protection flow
                    // with default prob
                    if (parameters_->zeroMarketPnl() && j > 0 &&
                        tradeCreditCurves_.find(tradeId) != tradeCreditCurves_.end()) {
                        string creditCurve = tradeCreditCurves_.at(tradeId);
                        sp = aggData_->get(j - 1, path, AggregationScenarioDataType::SurvivalWeight, creditCurve);
                        //rr = aggData_->get(j - 1, path, AggregationScenarioDataType::RecoveryRate, creditCurve);
                    }
                    if (j == 0) {
                        // at t0 we flip the sign of the npvs to get the initial cash balance
                        cash -= cube_->getT0(i, 0);
                        // collect intermediate cashflows
                        if (cubeIndexCashflows_ != Null<Size>())
                            cash += cube_->getT0(i, cubeIndexCashflows_);
                    } else if (j <= date) {
                        // collect intermediate cashflows
                        if (cubeIndexCashflows_ != Null<Size>())
                            cash += sp * cube_->get(i, j - 1, path, cubeIndexCashflows_);
                    } else {
                        // at the horizon date we realise the npv
                        cash += sp * cube_->get(i, j - 1, path, 0);
                    }
                }
            } // for data
        }     // if market risk
 
        if (!parameters_->creditRisk()) {
            // if we just add scalar market pnl realisations, we don't really need
            // the bucketing algorithm to do that, we just update the result
            // distribution directly
            res[hwBucketing.index(cash)] += 1.0 / static_cast<Real>(numPaths);
            continue;
        }
 
        // 2b credit migration pnl (at horizon date, over entities specified in credit simulation parameters)
 
        std::vector<Array> condProbs, pnl;
 
        if (evaluation_ != Evaluation::Analytic) {
            // 2b-1 generate pnl on the path using simulated idiosyncratic factors
            condProbs.resize(1, Array(parameters_->paths(), 1.0 / static_cast<Real>(parameters_->paths())));
            // we could build the distribution more efficiently here, but later in 2c we add the market pnl
            // maybe extend the hw bucketing so that we can feed precomputed distributions and just update
            // these with additional data?
            pnl.resize(1, Array(parameters_->paths(), 0.0));
            auto cond = initEntityStateSimulation(date, path);
            for (Size path2 = 0; path2 < parameters_->paths(); ++path2) {
                simulateEntityStates(cond, path, mt);
                pnl[0][path2] = generateMigrationPnl(date, path, n_);
            }
        } else {
            // 2b-2 generate pnl distribution without simulation of idiosyncratic factors using the conditional
            // independence of migration on the path / systemic factors
 
            // n+1 states, since for CDS we have to subdivide the issuer default into
            // i) default of issuer and non-default of CDS cpty
            // ii) default of issuer, default of CDS cpty (but after the issuer default)
            // iii) default of issuer, default of CDS cpty (before the issuer default)
            // for non-CDS trades for all sub-states the pnl will be set to the same value
            // for CDS trades i)+ii) will have the same pnl, but iii) will have a zero pnl
            // in total, we only have to distinguish i)+ii) and iii), i.e. we need one
            // additional state
 
            condProbs.resize(entities.size(), Array(n_ + 1, 0.0));
            pnl.resize(entities.size(), Array(n_ + 1, 0.0));
            generateConditionalMigrationPnl(date, path, transMat, condProbs, pnl);
        }
 
        // 2c aggregate market pnl and credit migration pnl
 
        if (parameters_->marketRisk()) {
            condProbs.push_back(Array(1, 1.0));
            pnl.push_back(Array(1, cash));
        }
 
        hwBucketing.computeMultiState(condProbs.begin(), condProbs.end(), pnl.begin());
 
        // 2d add pnl contribution of path to result distribution
        res += hwBucketing.probability() / static_cast<Real>(numPaths);
        // average market risk pnl
        avgCash += cash / static_cast<Real>(numPaths);
 
    } // for path
 
    DLOG("Expected Market Risk PnL at date " << date << ": " << avgCash);
    return res;
} // pnlDistribution

Here is the call graph for this function:

Here is the caller graph for this function:

rescaledTransitionMatrices()

std::map< string, Matrix > rescaledTransitionMatrices ( const Size  date )

private

Get the transition matrix from today to date by entity, sanitise the annual transition matrix input, rescale to the desired horizon/date using the generator, cache the result so that we do the sanitising/rescaling only once

Definition at line 87 of file creditmigrationhelper.cpp.

                                                                                        {
 
    std::map<string, Matrix> transMat; // rescaled transition matrix per (matrix) name
 
    // have we computed the result for the date index already?
    if (!rescaledTransitionMatrices_[date].empty()) {
        transMat = rescaledTransitionMatrices_[date];
    } else {
        Time t = cubeTimes_[date];
 
        const std::vector<string>& entities = parameters_->entities();
        const std::vector<string>& matrixNames = parameters_->transitionMatrices();
 
        for (Size i = 0; i < entities.size(); ++i) {
            if (transMat.count(matrixNames[i]) > 0) {
                DLOG("Transition matrix for " << entities[i] << " (" << matrixNames[i] << ") cached, nothing to do.");
            } else {
                QL_REQUIRE(parameters_->transitionMatrix().count(parameters_->transitionMatrices()[i]) > 0,
                           "No transition matrix defined for " << parameters_->entities()[i] << " / "
                                                               << parameters_->transitionMatrices()[i]);
                Matrix m = parameters_->transitionMatrix().at(parameters_->transitionMatrices()[i]);
                DLOG("Transition matrix (1y) for " << parameters_->entities()[i] << " is "
                                                   << parameters_->transitionMatrices()[i] << ":");
                DLOGGERSTREAM(m);
                if (n_ == Null<Size>()) {
                    n_ = m.rows();
                } else {
                    QL_REQUIRE(m.rows() == n_, "Found transition matrix with different dimension "
                                                   << m.rows() << "x" << m.columns() << " expected " << n_ << "x" << n_
                                                   << " for " << parameters_->entities()[i] << " / "
                                                   << parameters_->transitionMatrices()[i]);
                }
                QL_REQUIRE(date < cube_->numDates(),
                           "date index " << date << " outside range, cube has " << cube_->numDates() << " dates.");
                sanitiseTransitionMatrix(m);
                DLOG("Sanitised transition matrix:");
                DLOGGERSTREAM(m);
                Matrix g = QuantExt::generator(m);
                DLOG("Generator matrix:")
                DLOGGERSTREAM(g);
                checkGeneratorMatrix(g);
                Matrix mt = QuantExt::Expm(t * g);
                DLOG("Scaled transition matrix (t=" << t << "):");
                DLOGGERSTREAM(mt);
                checkTransitionMatrix(mt);
                Matrix mcheck = m;
                for (Size c = 1; c < static_cast<Size>(std::round(t)); ++c) {
                    mcheck = mcheck * m;
                }
                DLOG("Elementary transition matrix (t=" << std::round(t) << ", just for plausibility):");
                DLOGGERSTREAM(mcheck);
                transMat[matrixNames[i]] = mt;
            }
        }
        rescaledTransitionMatrices_[date] = transMat;
    }
 
    return transMat;
} // rescaledTransitionMatrices

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void init ( )

private

Initialise

• the variance of the global part Y_i of entity state X_i, for all entities
• the global part Y_i of entity i's state X_i by date index, entity index and sample number using the simulated global state paths stored in the aggregation scenario data object

Definition at line 147 of file creditmigrationhelper.cpp.

                                 {
 
    LOG("CreditMigrationHelper Init");
 
    n_ = Null<Size>(); // number of states
 
    Date asof = cube_->asof();
    for (Size d = 0; d < cube_->numDates(); ++d) {
        Date tDate = cube_->dates()[d];
        cubeTimes_.push_back(
            ActualActual(ActualActual::ISDA).yearFraction(asof, tDate)); // FIME make dc consistent with sim
    }
 
    const std::vector<Array>& loadings = parameters_->factorLoadings();
    Size f = globalFactorCorrelation_.rows();
    globalVar_.resize(parameters_->entities().size(), 0.0);
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        // variance of global factors
        QL_REQUIRE(parameters_->factorLoadings()[i].size() == f, "wrong size for loadings for entity "
                                                                     << parameters_->entities()[i] << " ("
                                                                     << loadings.size() << "), expected " << f);
        // don't optimise, code is simpler, matrix is small
        for (Size j = 0; j < loadings[i].size(); ++j) {
            for (Size k = 0; k < loadings[i].size(); ++k) {
                globalVar_[i] += loadings[i][j] * loadings[i][k] * globalFactorCorrelation_[j][k];
            }
        }
    }
 
    globalStates_.resize(cube_->numDates(), std::vector<std::vector<Real>>(parameters_->entities().size(),
                                                                           std::vector<Real>(cube_->samples())));
    Array globalFactors(f);
    std::vector<string> numStr(f);
    for (Size i = 0; i < f; ++i) {
        std::ostringstream num;
        num << i;
        numStr[i] = num.str();
    }
    for (Size d = 0; d < cube_->numDates(); ++d) {
        for (Size i = 0; i < parameters_->entities().size(); ++i) {
            for (Size j = 0; j < cube_->samples(); ++j) {
                for (Size ii = 0; ii < f; ++ii) {
                    globalFactors[ii] = aggData_->get(d, j, AggregationScenarioDataType::CreditState, numStr[ii]);
                }
                globalStates_[d][i][j] = DotProduct(loadings[i], globalFactors / std::sqrt(cubeTimes_[d]));
            }
        }
    }
 
    LOG("CreditMigration Init done.");
 
} // init

Here is the call graph for this function:

Here is the caller graph for this function:

initEntityStateSimulation() [1/2]

void initEntityStateSimulation ( )

private

Allocate 3d storage for the simulated idiosyncratic factors by entity, date and sample.

Definition at line 200 of file creditmigrationhelper.cpp.

                                                      {
 
    LOG("Init entity state simulation");
 
    simulatedEntityState_ =
        std::vector<std::vector<Size>>(parameters_->entities().size(), std::vector<Size>(cube_->samples()));
 
    LOG("Init entity state simulation done.");
 
} // initEntityStatesSimulation

Here is the caller graph for this function:

initEntityStateSimulation() [2/2]

std::vector< Matrix > initEntityStateSimulation ( const Size  date, const Size  path  )

private

Initialise the entity state simulationn for a given date for Evaluation = TerminalSimulation: Return transition matrix for each entity for the given date, conditional on the global terminal state on the given path

Definition at line 211 of file creditmigrationhelper.cpp.

                                                                                                   {
    std::vector<Matrix> res = std::vector<Matrix>(parameters_->entities().size(), Matrix(n_, n_, 0.0));
 
    const std::vector<string>& matrixNames = parameters_->transitionMatrices();
 
    // build terminal matrices conditional on global states
    Size numWarnings = 0;
    auto transMat = rescaledTransitionMatrices(date);
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        const Matrix& m = transMat.at(matrixNames[i]);
        for (Size ii = 0; ii < m.rows(); ++ii) {
            Real p = 0.0, condProb0 = 0.0;
            for (Size jj = 0; jj < m.columns(); ++jj) {
                p += m[ii][jj];
                Real condProb = conditionalProb(p, globalStates_[date][i][path], globalVar_[i]);
                res[i][ii][jj] = condProb - condProb0;
                condProb0 = condProb;
            }
        }
        try {
            checkTransitionMatrix(res[i]);
        } catch (const std::exception& e) {
            if (++numWarnings <= 10) {
                WLOG("Invalid conditional transition matrix (path=" << path << ", date=" << date << ", entity =" << i
                                                                    << ": " << e.what());
            } else if (numWarnings == 11) {
                WLOG("Suppress further warnings on invalid conditional transition matrices");
            }
            sanitiseTransitionMatrix(res[i]);
        }
    }
 
    // ... and finally build partial sums over columns for the simulation
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        Matrix& m = res[i];
        for (Size ii = 0; ii < m.rows(); ++ii) {
            for (Size jj = 1; jj < m.columns(); ++jj) {
                m[ii][jj] += m[ii][jj - 1];
            }
        }
    }
 
    return res;
}

Here is the call graph for this function:

simulateEntityStates()

void simulateEntityStates ( const std::vector< Matrix > &  cond, const Size  path, const MersenneTwisterUniformRng &  mt  )

private

Generate one entity state sample path for all entities given the global state path and given the conditional transition matrices for all entities at the terminal date.

Definition at line 256 of file creditmigrationhelper.cpp.

                                                                                      {
 
    QL_REQUIRE(evaluation_ != Evaluation::Analytic,
               "CreditMigrationHelper::simulateEntityStates() unexpected call, not in simulation mode");
 
    for (Size i = 0; i < parameters_->entities().size(); ++i) {
        Size initialState = parameters_->initialStates()[i];
            Real tmp = mt.next().value;
            Size entityState =
                std::lower_bound(cond[i].row_begin(initialState), cond[i].row_end(initialState), tmp) -
                cond[i].row_begin(initialState);
            entityState = std::min(entityState, cond[i].columns() - 1); // play safe
            simulatedEntityState_[i][path] = entityState;
            initialState = entityState;
    }
 
} // simulateEntityStates

Here is the call graph for this function:

Here is the caller graph for this function:

simulatedEntityState()

Size simulatedEntityState ( const Size  i, const Size  path  ) const

private

Look up the simulated entity credit state for the given entity, date and path.

Definition at line 275 of file creditmigrationhelper.cpp.

                                                                                    {
    QL_REQUIRE(evaluation_ != Evaluation::Analytic,
               "CreditMigrationHelper::simulatedEntityState() unexpected call, not in simulation mode");
    return simulatedEntityState_[i][path];
} // simulatedEntityState

Here is the caller graph for this function:

generateMigrationPnl()

Real generateMigrationPnl ( const Size  date, const Size  path, const Size  n  ) const

private

Return a single PnL impact due to credit migration or default of Bond/CDS issuers and default of netting set counterparties on the given global path

Definition at line 281 of file creditmigrationhelper.cpp.

                                                                                                     {
 
    QL_REQUIRE(!parameters_->doubleDefault(),
               "CreditMigrationHelper::generateMigrationPnl() does not support double default");
 
    const std::vector<string>& entities = parameters_->entities();
    Real pnl = 0.0;
 
    for (Size i = 0; i < entities.size(); ++i) {
        // compute credit state of entitiy
        // issuer migration risk
        Size simEntityState = simulatedEntityState(i, path);
        for (auto const& tradeId : issuerTradeIds_[i]) {
            try {
                Size tid = cube_->idsAndIndexes().at(tradeId);
                Real baseValue = cube_->get(tid, date, path, 0);
                Real stateValue = cube_->get(tid, date, path, cubeIndexStateNpvs_ + simEntityState);
                if (loanExposureMode_ == LoanExposureMode::Notional) {
                    if (tradeNotionals_.find(tradeId) != tradeNotionals_.end()) {
                        // this is a bond
                        string tradeCcy = tradeCurrencies_.at(tradeId);
                        string ccypair = tradeCcy + baseCurrency_;
                        Real fx = 1.0;
                        if (tradeCcy != baseCurrency_) {
                            QL_REQUIRE(aggData_->has(AggregationScenarioDataType::FXSpot, ccypair),
                                       "FX spot data not found in aggregation data for currency pair " << ccypair);
                            fx = aggData_->get(date, path, AggregationScenarioDataType::FXSpot, ccypair);
                        }
                        // FIXME: We actually need the correct current notional as of the future horizon date,
                        // but we have the current notional as of today
                        baseValue = tradeNotionals_.at(tradeId) * fx;
                        // FIXME: get the bond's recovery rate
                        Real rr = 0.0;
                        stateValue = simEntityState == n - 1 ? rr * baseValue : baseValue;
                    }
                    if (tradeCdsCptyIdx_.find(tradeId) != tradeCdsCptyIdx_.end()) {
                        // this is a cds
                        baseValue = 0.0;
                        if (simEntityState < n - 1)
                            stateValue = 0.0;
                        else
                            stateValue *= aggData_->get(date, path, AggregationScenarioDataType::Numeraire);
                    }
                }
                if (creditMode_ == CreditMode::Default && simEntityState < n - 1) {
                    stateValue = baseValue;
                }
                pnl += stateValue - baseValue;
            } catch (const std::exception& e) {
                ALOG("can not get state npv for trade " << tradeId << " (reason:" << e.what() << "), state "
                                                        << simEntityState << ", assume zero credit migration pnl");
            }
        }
        // default risk for derivative exposure
        // TODO, assuming a zero recovery here...
        for (auto const& nettingSetId : cptyNettingSetIds_[i]) {
            Size nid = nettedCube_->idsAndIndexes().at(nettingSetId);
            QL_REQUIRE(nettedCube_, "empty netted cube");
            if (simEntityState == n - 1)
                pnl -= std::max(nettedCube_->get(nid, date, path), 0.0);
        }
    }
    return pnl;
} // generateMigrationPnl

Here is the call graph for this function:

Here is the caller graph for this function:

generateConditionalMigrationPnl()

void generateConditionalMigrationPnl ( const Size  date, const Size  path, const std::map< string, Matrix > &  transMat, std::vector< Array > &  condProbs, std::vector< Array > &  pnl  ) const

private

Return a vector of PnL impacts and associated conditional probabilities for the specified global path, due to credit migration or default of Bond/CDS issuers and default of netting set counterparties

Definition at line 346 of file creditmigrationhelper.cpp.

                                                                                         {
 
    Real t = cubeTimes_[date];
 
    const std::vector<string>& entities = parameters_->entities();
    const std::vector<string>& matrixNames = parameters_->transitionMatrices();
 
    for (Size i = 0; i < entities.size(); ++i) {
        // compute conditional migration prob
        Size initialState = parameters_->initialStates()[i];
        Real p = 0.0, condProb0 = 0.0;
        const Matrix& m = transMat.at(matrixNames[i]);
        for (Size j = 0; j < n_; ++j) {
            p += m[initialState][j];
            Real condProb = conditionalProb(p, globalStates_[date][i][path], globalVar_[i]);
            condProbs[i][j] = condProb - condProb0;
            condProb0 = condProb;
        }
        // issuer migration risk
        Size cdsCptyIdx = Null<Size>();
        for (auto const& tradeId : issuerTradeIds_[i]) {
            for (Size j = 0; j < n_; ++j) {
                try {
                    Size tid = cube_->idsAndIndexes().at(tradeId);
                    Real baseValue = cube_->get(tid, date, path, 0);
                    Real stateValue = cube_->get(tid, date, path, cubeIndexStateNpvs_ + j);
                    if (loanExposureMode_ == LoanExposureMode::Notional) {
                        if (tradeNotionals_.find(tradeId) != tradeNotionals_.end()) {
                            // this is a bond
                            string tradeCcy = tradeCurrencies_.at(tradeId);
                            string ccypair = tradeCcy + baseCurrency_;
                            Real fx = 1.0;
                            if (tradeCcy != baseCurrency_) {
                                QL_REQUIRE(aggData_->has(AggregationScenarioDataType::FXSpot, ccypair),
                                           "FX spot data not found in aggregation data for currency pair " << ccypair);
                                fx = aggData_->get(date, path, AggregationScenarioDataType::FXSpot, ccypair);
                            }
                            // FIXME: We actually need the correct current notional as of the future horizon date,
                            // but we have the current notional as of today
                            baseValue = tradeNotionals_.at(tradeId) * fx;
                            // FIXME: get the bond's recovery rate
                            Real rr = 0.0;
                            stateValue = j == n_ - 1 ? rr * baseValue : baseValue;
                        }
                        if (tradeCdsCptyIdx_.find(tradeId) != tradeCdsCptyIdx_.end()) {
                            // this is a cds
                            baseValue = 0.0;
                            if (j < n_ - 1)
                                stateValue = 0.0;
                            else
                                stateValue *= aggData_->get(date, path, AggregationScenarioDataType::Numeraire);
                        }
                    }
                    if (creditMode_ == CreditMode::Default && j < n_ - 1) {
                        stateValue = baseValue;
                    }
                    pnl[i][j] += stateValue - baseValue;
                    // pnl for additional double default state
                    if (j == n_ - 1)
                        pnl[i][n_] += stateValue - baseValue;
                    // for a CDS we have to subdivide the default migration event into two events (see above)
                    if (parameters_->doubleDefault() && j == n_ - 1 &&
                        tradeCdsCptyIdx_.find(tradeId) != tradeCdsCptyIdx_.end()) {
                        // FIXME currently we can not handle two CDS cptys for same underlying issuer
                        QL_REQUIRE(cdsCptyIdx == Null<Size>() || cdsCptyIdx == tradeCdsCptyIdx_.at(tradeId),
                                   "CreditMigrationHelper: Two different CDS cptys found for same issuer "
                                       << entities[i]);
                        // only adjust probability once
                        if (cdsCptyIdx == Null<Size>()) {
                            Real cptyDefaultPd =
                                transMat.at(matrixNames[tradeCdsCptyIdx_.at(tradeId)])[initialState][n_ - 1];
                            Real pd = prob_tauA_lt_tauB_lt_T(cptyDefaultPd, condProbs[i][n_ - 1], t);
                            QL_REQUIRE(pd <= condProbs[i][n_ - 1],
                                       "CreditMigrationHelper: unexpected probability for double default event "
                                           << pd << " > " << condProbs[i][n_ - 1]);
                            condProbs[i][n_ - 1] -= pd;
                            condProbs[i][n_] = pd;
                            cdsCptyIdx = tradeCdsCptyIdx_.at(tradeId);
                            // pnl for new state is zero
                            pnl[i][n_] -= stateValue - baseValue;
                        }
                    }
                } catch (const std::exception& e) {
                    ALOG("can not get state npv for trade " << tradeId << " (reason:" << e.what() << "), state " << j
                                                            << ", assume zero credit migration pnl");
                }
            }
        }
        // default risk for derivative exposure
        // TODO, assuming a zero recovery here...
        for (auto const& nettingSetId : cptyNettingSetIds_[i]) {
            auto nid = nettedCube_->idsAndIndexes().at(nettingSetId);
            QL_REQUIRE(nettedCube_, "empty netted cube");
            pnl[i][n_ - 1] -= std::max(nettedCube_->get(nid, date, path), 0.0);
        }
    }
} // generateConditionalMigrationPnl

Here is the caller graph for this function:

Member Data Documentation

parameters_

QuantLib::ext::shared_ptr<CreditSimulationParameters> parameters_

private

Definition at line 109 of file creditmigrationhelper.hpp.

cube_

QuantLib::ext::shared_ptr<NPVCube> cube_

private

Definition at line 110 of file creditmigrationhelper.hpp.

nettedCube_

QuantLib::ext::shared_ptr<NPVCube> nettedCube_

private

Definition at line 110 of file creditmigrationhelper.hpp.

aggData_

QuantLib::ext::shared_ptr<AggregationScenarioData> aggData_

private

Definition at line 111 of file creditmigrationhelper.hpp.

cubeIndexCashflows_

Size cubeIndexCashflows_

private

Definition at line 112 of file creditmigrationhelper.hpp.

cubeIndexStateNpvs_

Size cubeIndexStateNpvs_

private

Definition at line 112 of file creditmigrationhelper.hpp.

globalFactorCorrelation_

Matrix globalFactorCorrelation_

private

Definition at line 113 of file creditmigrationhelper.hpp.

baseCurrency_

std::string baseCurrency_

private

Definition at line 114 of file creditmigrationhelper.hpp.

creditMode_

CreditMode creditMode_

private

Definition at line 116 of file creditmigrationhelper.hpp.

loanExposureMode_

LoanExposureMode loanExposureMode_

private

Definition at line 117 of file creditmigrationhelper.hpp.

evaluation_

Evaluation evaluation_

private

Definition at line 118 of file creditmigrationhelper.hpp.

cubeTimes_

std::vector<Real> cubeTimes_

private

Definition at line 119 of file creditmigrationhelper.hpp.

bucketing_

QuantExt::Bucketing bucketing_

private

Definition at line 121 of file creditmigrationhelper.hpp.

issuerTradeIds_

std::vector<std::set<std::string> > issuerTradeIds_

private

Definition at line 123 of file creditmigrationhelper.hpp.

cptyNettingSetIds_

std::vector<std::set<std::string> > cptyNettingSetIds_

private

Definition at line 124 of file creditmigrationhelper.hpp.

tradeCreditCurves_

std::map<std::string, std::string> tradeCreditCurves_

private

Definition at line 126 of file creditmigrationhelper.hpp.

tradeNotionals_

std::map<std::string, Real> tradeNotionals_

private

Definition at line 127 of file creditmigrationhelper.hpp.

tradeCurrencies_

std::map<std::string, std::string> tradeCurrencies_

private

Definition at line 128 of file creditmigrationhelper.hpp.

tradeCdsCptyIdx_

std::map<std::string, Size> tradeCdsCptyIdx_

private

Definition at line 129 of file creditmigrationhelper.hpp.

n_

Size n_

private

Definition at line 132 of file creditmigrationhelper.hpp.

rescaledTransitionMatrices_

std::vector<std::map<string, Matrix> > rescaledTransitionMatrices_

private

Definition at line 133 of file creditmigrationhelper.hpp.

globalVar_

std::vector<Real> globalVar_

private

Definition at line 135 of file creditmigrationhelper.hpp.

simulatedEntityState_

std::vector<std::vector<Size> > simulatedEntityState_

private

Definition at line 137 of file creditmigrationhelper.hpp.

entityStateSimulationMatrices_

std::vector<std::vector<Matrix> > entityStateSimulationMatrices_

private

Definition at line 139 of file creditmigrationhelper.hpp.

globalStates_

std::vector<std::vector<std::vector<Real> > > globalStates_

private

Definition at line 141 of file creditmigrationhelper.hpp.