HomogeneousPoolLossModel< copulaPolicy > Class Template Reference

Default loss distribution convolution for finite homogeneous pool. More...

#include <qle/models/homogeneouspooldef.hpp>

Inheritance diagram for HomogeneousPoolLossModel< copulaPolicy >:

Collaboration diagram for HomogeneousPoolLossModel< copulaPolicy >:

Public Member Functions
	HomogeneousPoolLossModel (const QuantLib::ext::shared_ptr< ConstantLossLatentmodel< copulaPolicy > > &copula, Size nBuckets, Real max=5., Real min=-5., Real nSteps=50)
Real	expectedTrancheLoss (const Date &d, bool zeroRecovery=false) const
Real	percentile (const Date &d, Real percentile) const
	Value at Risk given a default loss percentile. More...
Real	expectedShortfall (const Date &d, Probability percentile) const

Protected Member Functions
Distribution	lossDistrib (const Date &d, bool zeroRecovery=false) const
Protected Member Functions inherited from DefaultLossModel
	DefaultLossModel ()
virtual Real	expectedTrancheLoss (const Date &d, Real recoveryRate=Null< Real >()) const
virtual Probability	probOverLoss (const Date &d, Real lossFraction) const
virtual Real	expectedShortfall (const Date &d, Real percentile) const
	Expected shortfall given a default loss percentile. More...
virtual std::vector< Real >	splitVaRLevel (const Date &d, Real loss) const
	Associated VaR fraction to each counterparty. More...
virtual std::vector< Real >	splitESFLevel (const Date &d, Real loss) const
	Associated ESF fraction to each counterparty. More...
virtual std::map< Real, Probability >	lossDistribution (const Date &) const
	Full loss distribution. More...
virtual Real	densityTrancheLoss (const Date &d, Real lossFraction) const
	Probability density of a given loss fraction of the basket notional. More...
virtual std::vector< Probability >	probsBeingNthEvent (Size n, const Date &d) const
virtual Real	defaultCorrelation (const Date &d, Size iName, Size jName) const
	Pearsons' default probability correlation. More...
virtual Probability	probAtLeastNEvents (Size n, const Date &d) const
virtual Real	expectedRecovery (const Date &, Size iName, const DefaultProbKey &) const
virtual QuantLib::Real	correlation () const

Protected Attributes
const QuantLib::ext::shared_ptr< ConstantLossLatentmodel< copulaPolicy > >	copula_
Size	nBuckets_
Real	attach_
Real	detach_
Real	notional_
Real	attachAmount_
Real	detachAmount_
std::vector< Real >	notionals_
Protected Attributes inherited from DefaultLossModel
RelinkableHandle< QuantExt::Basket >	basket_

Private Member Functions
void	resetModel ()
	Concrete models do now any updates/inits they need on basket reset. More...

Private Attributes
const Real	max_
const Real	min_
const Real	nSteps_
const Real	delta_

Detailed Description

template<class copulaPolicy>
class QuantExt::HomogeneousPoolLossModel< copulaPolicy >

Default loss distribution convolution for finite homogeneous pool.

Definition at line 44 of file homogeneouspooldef.hpp.

Constructor & Destructor Documentation

HomogeneousPoolLossModel()

HomogeneousPoolLossModel	(	const QuantLib::ext::shared_ptr< ConstantLossLatentmodel< copulaPolicy > > &	copula,
		Size	nBuckets,
		Real	max = 5.,
		Real	min = -5.,
		Real	nSteps = 50
	)

Definition at line 49 of file homogeneouspooldef.hpp.

        : copula_(copula), nBuckets_(nBuckets), max_(max), min_(min), nSteps_(nSteps), delta_((max - min) / nSteps) {
        QL_REQUIRE(copula->numFactors() == 1, "Inhomogeneous model not implemented for multifactor");
    }

Here is the call graph for this function:

Member Function Documentation

resetModel()

void resetModel ( )

privatevirtual

Concrete models do now any updates/inits they need on basket reset.

Implements DefaultLossModel.

Definition at line 118 of file homogeneouspooldef.hpp.

                                                                  {
    // need to be capped now since the limit amounts might be over the
    //  remaining notional (think amortizing)
    attach_ = std::min(basket_->remainingAttachmentAmount() / basket_->remainingNotional(), 1.);
    detach_ = std::min(basket_->remainingDetachmentAmount() / basket_->remainingNotional(), 1.);
    notional_ = basket_->remainingNotional();
    notionals_ = basket_->remainingNotionals();
    attachAmount_ = basket_->remainingAttachmentAmount();
    detachAmount_ = basket_->remainingDetachmentAmount();
 
    copula_->resetBasket(basket_.currentLink());
}

lossDistrib()

Distribution lossDistrib ( const Date &  d, bool  zeroRecovery = false  ) const

protected

Definition at line 132 of file homogeneouspooldef.hpp.

                                                                                                                 {
    LossDistHomogeneous bucktLDistBuff(nBuckets_, detachAmount_);
 
    std::vector<Real> lgd; // switch to a mutable cache member
    // RL: additional option used to set set recovery rates to zero
    // std::vector<Real> recoveries = copula_->recoveries();
    std::vector<Real> recoveries =
        zeroRecovery ? std::vector<Real>(copula_->recoveries().size(), 0.0) : copula_->recoveries();
    std::transform(recoveries.begin(), recoveries.end(), std::back_inserter(lgd), [](Real x) { return 1.0 - x; });
    std::transform(lgd.begin(), lgd.end(), notionals_.begin(), lgd.begin(), std::multiplies<Real>());
    std::vector<Real> prob = basket_->remainingProbabilities(d);
    for (Size iName = 0; iName < prob.size(); iName++)
        prob[iName] = copula_->inverseCumulativeY(prob[iName], iName);
 
    // integrate locally (1 factor).
    // use explicitly a 1D latent model object?
    Distribution dist(nBuckets_, 0.0, detachAmount_);
    // notional_);
    std::vector<Real> mkft(1, min_ + delta_ / 2.);
    for (Size i = 0; i < nSteps_; i++) {
        std::vector<Real> conditionalProbs;
        for (Size iName = 0; iName < notionals_.size(); iName++)
            conditionalProbs.push_back(copula_->conditionalDefaultProbabilityInvP(prob[iName], iName, mkft));
        Distribution d = bucktLDistBuff(lgd, conditionalProbs);
        Real densitydm = delta_ * copula_->density(mkft);
        // also, instead of calling the static method it could be wrapped
        // through an inlined call in the latent model
        for (Size j = 0; j < nBuckets_; j++) {
            dist.addDensity(j, d.density(j) * densitydm);
            dist.addAverage(j, d.average(j) * densitydm); // RL
        }
        mkft[0] += delta_;
    }
    return dist;
}

Here is the caller graph for this function:

expectedTrancheLoss()

Real expectedTrancheLoss	(	const Date &	d,
		bool	zeroRecovery = false
	)		const

Definition at line 61 of file homogeneouspooldef.hpp.

                                                                             {
        Distribution dist = lossDistrib(d, zeroRecovery);
        // RL: dist.trancheExpectedValue() using x = dist.average(i)
        // FIXME: some remaining inaccuracy in dist.cumulativeDensity(detachAmount_)
        Real expectedLoss = 0;
        dist.normalize();
        for (Size i = 0; i < dist.size(); i++) {
            // Real x = dist.x(i) + dist.dx(i)/2; // in QL distribution.cpp
            Real x = dist.average(i);
            if (x < attachAmount_)
                continue;
            if (x > detachAmount_)
                break;
            expectedLoss += (x - attachAmount_) * dist.dx(i) * dist.density(i);
        }
        expectedLoss += (detachAmount_ - attachAmount_) * (1.0 - dist.cumulativeDensity(detachAmount_));
        return expectedLoss;
 
        return lossDistrib(d, zeroRecovery).cumulativeExcessProbability(attachAmount_, detachAmount_);
        // This one if the distribution is over the whole loss structure:
        // but it becomes very expensive
        /*
        return lossDistrib(d).trancheExpectedValue(attach_ * notional_,
            detach_ * notional_);
        */
    }

Here is the call graph for this function:

percentile()

Real percentile ( const Date &  d, Real  percentile  ) const

virtual

Value at Risk given a default loss percentile.

Reimplemented from DefaultLossModel.

Definition at line 87 of file homogeneouspooldef.hpp.

                                                          {
        Real portfLoss = lossDistrib(d).confidenceLevel(percentile);
        return std::min(std::max(portfLoss - attachAmount_, 0.), detachAmount_ - attachAmount_);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

expectedShortfall()

Real expectedShortfall	(	const Date &	d,
		Probability	percentile
	)		const

Definition at line 91 of file homogeneouspooldef.hpp.

                                                                        {
        Distribution dist = lossDistrib(d);
        dist.tranche(attachAmount_, detachAmount_);
        return dist.expectedShortfall(percentile);
    }

Here is the call graph for this function:

Member Data Documentation

copula_

const QuantLib::ext::shared_ptr<ConstantLossLatentmodel<copulaPolicy> > copula_

protected

Definition at line 98 of file homogeneouspooldef.hpp.

nBuckets_

Size nBuckets_

protected

Definition at line 99 of file homogeneouspooldef.hpp.

attach_

Real attach_

mutableprotected

Definition at line 100 of file homogeneouspooldef.hpp.

detach_

Real detach_

protected

Definition at line 100 of file homogeneouspooldef.hpp.

notional_

Real notional_

protected

Definition at line 100 of file homogeneouspooldef.hpp.

attachAmount_

Real attachAmount_

protected

Definition at line 100 of file homogeneouspooldef.hpp.

detachAmount_

Real detachAmount_

protected

Definition at line 100 of file homogeneouspooldef.hpp.

notionals_

std::vector<Real> notionals_

mutableprotected

Definition at line 101 of file homogeneouspooldef.hpp.

max_

const Real max_

private

Definition at line 107 of file homogeneouspooldef.hpp.

min_

const Real min_

private

Definition at line 108 of file homogeneouspooldef.hpp.

nSteps_

const Real nSteps_

private

Definition at line 109 of file homogeneouspooldef.hpp.

delta_

const Real delta_

private

Definition at line 110 of file homogeneouspooldef.hpp.