Synthetic Collateralized Debt Obligation. More...

#include <qle/instruments/syntheticcdo.hpp>

Inheritance diagram for SyntheticCDO:

Collaboration diagram for SyntheticCDO:

Classes
class	arguments

class	engine
	CDO base engine. More...

class	results

Public Member Functions
	SyntheticCDO (const QuantLib::ext::shared_ptr< QuantExt::Basket > &basket, Protection::Side side, const Schedule &schedule, Rate upfrontRate, Rate runningRate, const DayCounter &dayCounter, BusinessDayConvention paymentConvention, bool settlesAccrual=true, const QuantLib::CreditDefaultSwap::ProtectionPaymentTime protectionPaymentTime=QuantLib::CreditDefaultSwap::ProtectionPaymentTime::atDefault, Date protectionStart=Date(), Date upfrontDate=Date(), boost::optional< Real > notional=boost::none, Real recoveryRate=Null< Real >(), const DayCounter &lastPeriodDayCounter=DayCounter())

const QuantLib::ext::shared_ptr< QuantExt::Basket > &	basket () const

bool	isExpired () const override

Rate	fairPremium () const

Rate	fairUpfrontPremium () const

Rate	premiumValue () const

Rate	protectionValue () const

Real	premiumLegNPV () const

Real	protectionLegNPV () const

Real	recoveryRate () const
	Returns the recovery rate for fixed recovery CDO, otherwise returns Null<Real>() More...

Real	remainingNotional () const

Real	leverageFactor () const

const Date &	maturity () const
	Last protection date. More...

Real	implicitCorrelation (const std::vector< Real > &recoveries, const Handle< YieldTermStructure > &discountCurve, Real targetNPV=0., Real accuracy=1.0e-3) const

std::vector< Real >	expectedTrancheLoss () const

Size	error () const

void	setupArguments (PricingEngine::arguments *) const override

void	fetchResults (const PricingEngine::results *) const override

Private Member Functions
void	setupExpired () const override

Private Attributes
QuantLib::ext::shared_ptr< QuantExt::Basket >	basket_

Protection::Side	side_

Leg	normalizedLeg_

Rate	upfrontRate_

Rate	runningRate_

const Real	leverageFactor_

DayCounter	dayCounter_

BusinessDayConvention	paymentConvention_

bool	settlesAccrual_

QuantLib::CreditDefaultSwap::ProtectionPaymentTime	protectionPaymentTime_

Date	protectionStart_

Date	upfrontDate_

QuantLib::ext::shared_ptr< CashFlow >	upfrontPayment_

QuantLib::ext::shared_ptr< CashFlow >	accrualRebate_

QuantLib::ext::shared_ptr< CashFlow >	accrualRebateCurrent_

Real	recoveryRate_

Real	premiumValue_

Real	protectionValue_

Real	upfrontPremiumValue_

Real	remainingNotional_

Size	error_

std::vector< Real >	expectedTrancheLoss_

Detailed Description

Synthetic Collateralized Debt Obligation.

The instrument prices a mezzanine CDO tranche with loss given default between attachment point \( D_1\) and detachment point \( D_2 > D_1 \).

For purchased protection, the instrument value is given by the difference of the protection value \( V_1 \) and premium value \( V_2 \),

\[ V = V_1 - V_2. \]

The protection leg is priced as follows:

Build the probability distribution for volume of defaults \( L \) (before recovery) or Loss Given Default \( LGD = (1-r)\,L \) at times/dates \( t_i, i=1, ..., N\) (premium schedule times with intermediate steps)
Determine the expected value \( E_i = E_{t_i}\,\left[Pay(LGD)\right] \) of the protection payoff \( Pay(LGD) \) at each time \( t_i\) where
\[ Pay(L) = min (D_1, LGD) - min (D_2, LGD) = \left\{ \begin{array}{lcl} \displaystyle 0 &;& LGD < D_1 \\ \displaystyle LGD - D_1 &;& D_1 \leq LGD \leq D_2 \\ \displaystyle D_2 - D_1 &;& LGD > D_2 \end{array} \right. \]
The protection value is then calculated as
\[ V_1 \:=\: \sum_{i=1}^N (E_i - E_{i-1}) \cdot d_i \]
where \( d_i\) is the discount factor at time/date \( t_i \)

The premium is paid on the protected notional amount, initially \( D_2 - D_1. \) This notional amount is reduced by the expected protection payments \( E_i \) at times \( t_i, \) so that the premium value is calculated as

\[ V_2 =m \, \cdot \sum_{i=1}^N \,(D_2 - D_1 - E_i) \cdot \Delta_{i-1,i}\,d_i \]

where \( m \) is the premium rate, \( \Delta_{i-1, i}\) is the day count fraction between date/time \( t_{i-1}\) and \( t_i.\)

The construction of the portfolio loss distribution \( E_i \) is based on the probability bucketing algorithm described in

John Hull and Alan White, "Valuation of a CDO and nth to default CDS without Monte Carlo simulation", Journal of Derivatives 12, 2, 2004

The pricing algorithm allows for varying notional amounts and default termstructures of the underlyings.

Definition at line 108 of file syntheticcdo.hpp.

Constructor & Destructor Documentation

◆ SyntheticCDO()

SyntheticCDO	(	const QuantLib::ext::shared_ptr< QuantExt::Basket > &	basket,
		Protection::Side	side,
		const Schedule &	schedule,
		Rate	upfrontRate,
		Rate	runningRate,
		const DayCounter &	dayCounter,
		BusinessDayConvention	paymentConvention,
		bool	settlesAccrual = `true`,
		const QuantLib::CreditDefaultSwap::ProtectionPaymentTime	protectionPaymentTime = `QuantLib::CreditDefaultSwap::ProtectionPaymentTime::atDefault`,
		Date	protectionStart = `Date()`,
		Date	upfrontDate = `Date()`,
		boost::optional< Real >	notional = `boost::none`,
		Real	recoveryRate = `Null<Real>()`,
		const DayCounter &	lastPeriodDayCounter = `DayCounter()`
	)

If the notional exceeds the basket inception tranche notional, the cdo is leveraged by that factor.

Definition at line 40 of file syntheticcdo.cpp.

    : basket_(basket), side_(side), upfrontRate_(upfrontRate), runningRate_(runningRate),
      leverageFactor_(notional ? notional.get() / basket->trancheNotional() : 1.), dayCounter_(dayCounter),
      paymentConvention_(paymentConvention), settlesAccrual_(settlesAccrual),
      protectionPaymentTime_(protectionPaymentTime),
      protectionStart_(protectionStart == Null<Date>() ? schedule[0] : protectionStart),
      recoveryRate_(recoveryRate) {
    QL_REQUIRE((schedule.rule() == DateGeneration::CDS || schedule.rule() == DateGeneration::CDS2015) ||
                   protectionStart_ <= schedule[0],
               "protection can not start after accrual for (pre big bang-) CDS");
    QL_REQUIRE(basket->names().size() > 0, "basket is empty");
    // Basket inception must lie before contract protection start.
    QL_REQUIRE(basket->refDate() <= schedule.startDate(),
               // using the start date of the schedule might be wrong, think of the
               //  CDS rule
               "Basket did not exist before contract start.");
 
    // Notice the notional is that of the basket at basket inception, some
    //   names might have defaulted in between
    normalizedLeg_ = FixedRateLeg(schedule)
                         .withNotionals(basket_->trancheNotional() * leverageFactor_)
                         .withCouponRates(runningRate, dayCounter)
                         .withPaymentAdjustment(paymentConvention)
                         .withLastPeriodDayCounter(lastPeriodDayCounter);
 
    // If empty, adjust to T+3 standard settlement
    Date effectiveUpfrontDate =
        upfrontDate == Null<Date>()
            ? schedule.calendar().advance(schedule.calendar().adjust(protectionStart_, paymentConvention), 3, Days,
                                          paymentConvention)
            : upfrontDate;
    // '2' is used above since the protection start is assumed to be
    // on trade_date + 1
    upfrontPayment_.reset(
        new SimpleCashFlow(basket_->trancheNotional() * leverageFactor_ * upfrontRate, effectiveUpfrontDate));
 
    QL_REQUIRE(upfrontPayment_->date() >= protectionStart_, "upfront can not be due before contract start");
 
    if (schedule.rule() == DateGeneration::CDS || schedule.rule() == DateGeneration::CDS2015) {
            accrualRebate_= QuantLib::ext::make_shared<SimpleCashFlow>(QuantLib::CashFlows::accruedAmount(normalizedLeg_, false, protectionStart_+1),
                                                               effectiveUpfrontDate);      
            Date current = std::max((Date)Settings::instance().evaluationDate(), protectionStart_);
            accrualRebateCurrent_ = QuantLib::ext::make_shared<SimpleCashFlow>(
                CashFlows::accruedAmount(normalizedLeg_, false, current + 1),
                schedule.calendar().advance(current, 3, Days, paymentConvention));
 
    }
 
   
 
    // register with probabilities if the corresponding issuer is, baskets
    //   are not registered with the DTS
    for (Size i = 0; i < basket->names().size(); i++) {
        /* This turns out to be a problem: depends on today but I am not
        modifying the registrations, if we go back in time in the
        calculations this would left me unregistered to some. Not impossible
        to de-register and register when updating but i am dropping it.
 
        if(!basket->pool()->get(basket->names()[i]).
            defaultedBetween(schedule.dates()[0], today,
                                 basket->pool()->defaultKeys()[i]))
        */
        // registers with the associated curve (issuer and event type)
        // \todo make it possible to access them by name instead of index
        registerWith(basket->pool()->get(basket->names()[i]).defaultProbability(basket->pool()->defaultKeys()[i]));
        /* \todo Issuers should be observables/obsrvr and they would in turn
        regiter with the DTS; only we might get updates from curves we do
        not use.
        */
    }
    registerWith(basket_);
}

Here is the call graph for this function:

Member Function Documentation

◆ basket()

const QuantLib::ext::shared_ptr< QuantExt::Basket > & basket ( ) const

Definition at line 134 of file syntheticcdo.hpp.

134{ return basket_; }

Here is the caller graph for this function:

◆ isExpired()

bool isExpired ( ) const

override

Definition at line 162 of file syntheticcdo.cpp.

                                   {
    // FIXME: it could have also expired (knocked out) because theres
    //   no remaining tranche notional.
    return detail::simple_event(normalizedLeg_.back()->date()).hasOccurred();
}

◆ fairPremium()

Rate fairPremium ( ) const

Definition at line 142 of file syntheticcdo.cpp.

                                     {
    calculate();
    return runningRate_ * (protectionValue_ - upfrontPremiumValue_) / premiumValue_;
}

◆ fairUpfrontPremium()

Rate fairUpfrontPremium ( ) const

Definition at line 147 of file syntheticcdo.cpp.

                                            {
    calculate();
    return (protectionValue_ - premiumValue_) / remainingNotional_;
}

◆ premiumValue()

Rate premiumValue ( ) const

Definition at line 118 of file syntheticcdo.cpp.

                                      {
    calculate();
    return premiumValue_;
}

Here is the caller graph for this function:

◆ protectionValue()

Rate protectionValue ( ) const

Definition at line 123 of file syntheticcdo.cpp.

                                         {
    calculate();
    return protectionValue_;
}

Here is the caller graph for this function:

◆ premiumLegNPV()

Real premiumLegNPV ( ) const

Definition at line 128 of file syntheticcdo.cpp.

                                       {
    calculate();
    if (side_ == Protection::Buyer)
        return premiumValue_;
    return -premiumValue_;
}

◆ protectionLegNPV()

Real protectionLegNPV ( ) const

Definition at line 135 of file syntheticcdo.cpp.

                                          {
    calculate();
    if (side_ == Protection::Buyer)
        return -protectionValue_;
    return premiumValue_;
}

◆ recoveryRate()

Real recoveryRate ( ) const

Returns the recovery rate for fixed recovery CDO, otherwise returns Null<Real>()

Definition at line 144 of file syntheticcdo.hpp.

144{ return recoveryRate_; }

◆ remainingNotional()

Real remainingNotional ( ) const

Total outstanding tranche notional, not wiped out

Definition at line 168 of file syntheticcdo.cpp.

                                           {
    calculate();
    return remainingNotional_;
}

Here is the caller graph for this function:

◆ leverageFactor()

Real leverageFactor ( ) const

The number of times the contract contains the portfolio tranched notional.

Definition at line 152 of file syntheticcdo.hpp.

152{ return leverageFactor_; }

◆ maturity()

const Date & maturity ( ) const

Last protection date.

Definition at line 154 of file syntheticcdo.hpp.

                                 {
        return QuantLib::ext::dynamic_pointer_cast<FixedRateCoupon>(normalizedLeg_.back())->accrualEndDate();
    }

Here is the caller graph for this function:

◆ implicitCorrelation()

Real implicitCorrelation	(	const std::vector< Real > &	recoveries,
		const Handle< YieldTermStructure > &	discountCurve,
		Real	targetNPV = `0.`,
		Real	accuracy = `1.0e-3`
	)		const

The Gaussian Copula LHP implied correlation that makes the contract zero value. This is for a flat correlation along time and portfolio loss level.

Definition at line 259 of file syntheticcdo.cpp.

                                                            {
    QuantLib::ext::shared_ptr<SimpleQuote> correl(new SimpleQuote(0.0));
 
    QuantLib::ext::shared_ptr<GaussianLHPLossModel> lhp(new GaussianLHPLossModel(Handle<Quote>(correl), recoveries));
 
    // lock
    basket_->setLossModel(lhp);
 
    QuantExt::MidPointCDOEngine engineIC(discountCurve);
    setupArguments(engineIC.getArguments());
    const SyntheticCDO::results* results = dynamic_cast<const SyntheticCDO::results*>(engineIC.getResults());
 
    // aviod recal of the basket on engine updates through the quote
    basket_->recalculate();
    basket_->freeze();
 
    ObjectiveFunction f(targetNPV, *correl, engineIC, results);
    Rate guess = 0.001;
    //  Rate step = guess*0.1;
 
    // wrap/catch to be able to unfreeze the basket:
    Real solution = Brent().solve(f, accuracy, guess, QL_EPSILON, 1. - QL_EPSILON);
    basket_->unfreeze();
    return solution;
}

Here is the call graph for this function:

◆ expectedTrancheLoss()

vector< Real > expectedTrancheLoss ( ) const

Expected tranche loss for all payment dates

Definition at line 152 of file syntheticcdo.cpp.

                                                     {
    calculate();
    return expectedTrancheLoss_;
}

Here is the caller graph for this function:

◆ error()

Size error ( ) const

Definition at line 157 of file syntheticcdo.cpp.

                               {
    calculate();
    return error_;
}

Here is the caller graph for this function:

◆ setupArguments()

void setupArguments ( PricingEngine::arguments * args ) const

override

Definition at line 173 of file syntheticcdo.cpp.

                                                                    {
    SyntheticCDO::arguments* arguments = dynamic_cast<SyntheticCDO::arguments*>(args);
    QL_REQUIRE(arguments != 0, "wrong argument type");
    arguments->basket = basket_;
    arguments->side = side_;
    arguments->normalizedLeg = normalizedLeg_;
 
    arguments->upfrontRate = upfrontRate_;
    arguments->runningRate = runningRate_;
    arguments->dayCounter = dayCounter_;
    arguments->paymentConvention = paymentConvention_;
    arguments->leverageFactor = leverageFactor_;
    arguments->upfrontPayment = upfrontPayment_;
    arguments->accrualRebate = accrualRebate_;
    arguments->accrualRebateCurrent = accrualRebateCurrent_;
    arguments->settlesAccrual = settlesAccrual_;
    arguments->protectionPaymentTime = protectionPaymentTime_;
    arguments->protectionStart = protectionStart_;
    arguments->maturity = maturity();
    arguments->recoveryRate = recoveryRate_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fetchResults()

void fetchResults ( const PricingEngine::results * r ) const

override

Definition at line 195 of file syntheticcdo.cpp.

                                                                   {
    Instrument::fetchResults(r);
 
    const SyntheticCDO::results* results = dynamic_cast<const SyntheticCDO::results*>(r);
    QL_REQUIRE(results != 0, "wrong result type");
 
    premiumValue_ = results->premiumValue;
    protectionValue_ = results->protectionValue;
    upfrontPremiumValue_ = results->upfrontPremiumValue;
    remainingNotional_ = results->remainingNotional;
    error_ = results->error;
    expectedTrancheLoss_ = results->expectedTrancheLoss;
}

◆ setupExpired()

void setupExpired ( ) const

overrideprivate

Definition at line 209 of file syntheticcdo.cpp.

                                      {
    Instrument::setupExpired();
    premiumValue_ = 0.0;
    protectionValue_ = 0.0;
    upfrontPremiumValue_ = 0.0;
    remainingNotional_ = 1.0;
    expectedTrancheLoss_.clear();
}

Member Data Documentation

◆ basket_

QuantLib::ext::shared_ptr<QuantExt::Basket> basket_

private

Definition at line 177 of file syntheticcdo.hpp.

◆ side_

Protection::Side side_

private

Definition at line 178 of file syntheticcdo.hpp.

◆ normalizedLeg_

Leg normalizedLeg_

private

Definition at line 179 of file syntheticcdo.hpp.

◆ upfrontRate_

Rate upfrontRate_

private

Definition at line 181 of file syntheticcdo.hpp.

◆ runningRate_

Rate runningRate_

private

Definition at line 182 of file syntheticcdo.hpp.

◆ leverageFactor_

const Real leverageFactor_

private

Definition at line 183 of file syntheticcdo.hpp.

◆ dayCounter_

DayCounter dayCounter_

private

Definition at line 184 of file syntheticcdo.hpp.

◆ paymentConvention_

BusinessDayConvention paymentConvention_

private

Definition at line 185 of file syntheticcdo.hpp.

◆ settlesAccrual_

bool settlesAccrual_

private

Definition at line 186 of file syntheticcdo.hpp.

◆ protectionPaymentTime_

QuantLib::CreditDefaultSwap::ProtectionPaymentTime protectionPaymentTime_

private

Definition at line 187 of file syntheticcdo.hpp.

◆ protectionStart_

Date protectionStart_

private

Definition at line 188 of file syntheticcdo.hpp.

◆ upfrontDate_

Date upfrontDate_

private

Definition at line 189 of file syntheticcdo.hpp.

◆ upfrontPayment_

QuantLib::ext::shared_ptr<CashFlow> upfrontPayment_

private

Definition at line 190 of file syntheticcdo.hpp.

◆ accrualRebate_

QuantLib::ext::shared_ptr<CashFlow> accrualRebate_

private

Definition at line 190 of file syntheticcdo.hpp.

◆ accrualRebateCurrent_

QuantLib::ext::shared_ptr<CashFlow> accrualRebateCurrent_

private

Definition at line 190 of file syntheticcdo.hpp.

◆ recoveryRate_

Real recoveryRate_

private

Definition at line 191 of file syntheticcdo.hpp.

◆ premiumValue_

Real premiumValue_

mutableprivate

Definition at line 193 of file syntheticcdo.hpp.

◆ protectionValue_

Real protectionValue_

mutableprivate

Definition at line 194 of file syntheticcdo.hpp.

◆ upfrontPremiumValue_

Real upfrontPremiumValue_

mutableprivate

Definition at line 195 of file syntheticcdo.hpp.

◆ remainingNotional_

Real remainingNotional_

mutableprivate

Definition at line 196 of file syntheticcdo.hpp.

◆ error_

Size error_

mutableprivate

Definition at line 197 of file syntheticcdo.hpp.

◆ expectedTrancheLoss_

std::vector<Real> expectedTrancheLoss_

mutableprivate

Definition at line 198 of file syntheticcdo.hpp.

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SyntheticCDO()

Member Function Documentation

◆ basket()

◆ isExpired()

◆ fairPremium()

◆ fairUpfrontPremium()

◆ premiumValue()

◆ protectionValue()

◆ premiumLegNPV()

◆ protectionLegNPV()

◆ recoveryRate()

◆ remainingNotional()

◆ leverageFactor()

◆ maturity()

◆ implicitCorrelation()

◆ expectedTrancheLoss()

◆ error()

◆ setupArguments()

◆ fetchResults()

◆ setupExpired()

Member Data Documentation

◆ basket_

◆ side_

◆ normalizedLeg_

◆ upfrontRate_

◆ runningRate_

◆ leverageFactor_

◆ dayCounter_

◆ paymentConvention_

◆ settlesAccrual_

◆ protectionPaymentTime_

◆ protectionStart_

◆ upfrontDate_

◆ upfrontPayment_

◆ accrualRebate_

◆ accrualRebateCurrent_

◆ recoveryRate_

◆ premiumValue_

◆ protectionValue_

◆ upfrontPremiumValue_

◆ remainingNotional_

◆ error_

◆ expectedTrancheLoss_