SyntheticCDO Class Reference

Synthetic Collateralized Debt Obligation. More...

`#include <ql/experimental/credit/syntheticcdo.hpp>`

Inheritance diagram for SyntheticCDO:
[legend]

## Classes

class | engine
| CDO base engine. More...

## Public Member Functions

| SyntheticCDO (const boost::shared_ptr< Basket > &basket, Protection::Side side, const Schedule &schedule, Rate upfrontRate, Rate runningRate, const DayCounter &dayCounter, BusinessDayConvention paymentConvention, boost::optional< Real > notional=boost::none)
const boost::shared_ptr< Basket > & | basket () const
bool | isExpired () const
| returns whether the instrument might have value greater than zero.
Rate | fairPremium () const
Rate | fairUpfrontPremium () const
Rate | premiumValue () const
Rate | protectionValue () const
Real | premiumLegNPV () const
Real | protectionLegNPV () const
Real | remainingNotional () const
Real | leverageFactor () const
const Date & | maturity () const
| Last protection date.
Real | implicitCorrelation (const std::vector< Real > &recoveries, const Handle< YieldTermStructure > &discountCurve, Real targetNPV=0., Real accuracy=1.0e-3) const
Disposable< std::vector< Real > > | expectedTrancheLoss () const
Size | error () const
void | setupArguments (PricingEngine::arguments *) const
void | fetchResults (const PricingEngine::results *) const
Public Member Functions inherited from Instrument
Real | NPV () const
| returns the net present value of the instrument.
Real | errorEstimate () const
| returns the error estimate on the NPV when available.
const Date & | valuationDate () const
| returns the date the net present value refers to.
template<typename T >
T | result (const std::string &tag) const
| returns any additional result returned by the pricing engine.
const std::map< std::string, boost::any > & | additionalResults () const
| returns all additional result returned by the pricing engine.
void | setPricingEngine (const boost::shared_ptr< PricingEngine > &)
| set the pricing engine to be used. More...
Public Member Functions inherited from LazyObject
void | update ()
void | recalculate ()
void | freeze ()
void | unfreeze ()
Public Member Functions inherited from Observable
| Observable (const Observable &)
Observable & | operator= (const Observable &)
void | notifyObservers ()
Public Member Functions inherited from Observer
| Observer (const Observer &)
Observer & | operator= (const Observer &)
std::pair< std::set< boost::shared_ptr< Observable > >::iterator, bool > | registerWith (const boost::shared_ptr< Observable > &)
void | registerWithObservables (const boost::shared_ptr< Observer > &)
Size | unregisterWith (const boost::shared_ptr< Observable > &)
void | unregisterWithAll ()

## Additional Inherited Members

Protected Member Functions inherited from Instrument
void | calculate () const
virtual void | performCalculations () const
Protected Member Functions inherited from LazyObject
Protected Attributes inherited from Instrument
boost::shared_ptr< PricingEngine > | engine_
Real | NPV_
Real | errorEstimate_
Date | valuationDate_
std::map< std::string, boost::any > | additionalResults_
Protected Attributes inherited from LazyObject
bool | calculated_
bool | frozen_

## 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.

## Constructor & Destructor Documentation

SyntheticCDO | ( | const boost::shared_ptr< Basket > & | basket,
|  | Protection::Side | side,
|  | const Schedule & | schedule,
|  | Rate | upfrontRate,
|  | Rate | runningRate,
|  | const DayCounter & | dayCounter,
|  | BusinessDayConvention | paymentConvention,
|  | boost::optional< Real > | notional = `boost::none`
| ) |  |

Parameters

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

## Member Function Documentation

Real remainingNotional | ( |  | ) | const

Total outstanding tranche notional, not wiped out

Real leverageFactor | ( |  | ) | const

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

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.

Disposable<std::vector<Real> > expectedTrancheLoss | ( |  | ) | const

Expected tranche loss for all payment dates

void setupArguments | ( | PricingEngine::arguments * |  | ) | const

virtual

When a derived argument structure is defined for an instrument, this method should be overridden to fill it. This is mandatory in case a pricing engine is used.

Reimplemented from Instrument.

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

virtual

When a derived result structure is defined for an instrument, this method should be overridden to read from it. This is mandatory in case a pricing engine is used.

Reimplemented from Instrument.