IndexCdsTrancheEngine Class Reference

#include <qle/pricingengines/indexcdstrancheengine.hpp>

Inheritance diagram for IndexCdsTrancheEngine:

Collaboration diagram for IndexCdsTrancheEngine:

Public Member Functions
	IndexCdsTrancheEngine (const QuantLib::Handle< QuantLib::YieldTermStructure > &discountCurve, boost::optional< bool > includeSettlementDateFlows=boost::none)
void	calculate () const override

Protected Attributes
QuantLib::Handle< QuantLib::YieldTermStructure >	discountCurve_
boost::optional< bool >	includeSettlementDateFlows_

Detailed Description

Index tranche pricing engine

The engine obtains the index CDS reference basket from its arguments and it is expecting it to have a default model assigned.

This engine prices standard index CDS tranches. The mechanics of such tranches is outlined in Markit Credit Indices A Primer, 2014 for example available on the Markit website.

Warning:

We do not cover the possibility that recovery amounts decrease the tranche notional on which the premium is paid. For tranche detachment points met in practice, it is rare that recovery amounts exceed the notional of the super-senior tranche and thus erode the notional of the other tranches. If we want to cover this possibility we would need to extend the basket loss model algorithms so that they account for losses on a tranche notional due to recovery amounts in addition to the losses due to default. In summary, do not expect this pricing engine to work well for tranches with high detachment points which are likely to be breached by the sum of recovered amounts as the premium leg will be over-estimated in those situations.

Definition at line 52 of file indexcdstrancheengine.hpp.

Constructor & Destructor Documentation

IndexCdsTrancheEngine()

IndexCdsTrancheEngine	(	const QuantLib::Handle< QuantLib::YieldTermStructure > &	discountCurve,
		boost::optional< bool >	includeSettlementDateFlows = boost::none
	)

Definition at line 33 of file indexcdstrancheengine.cpp.

    : discountCurve_(discountCurve),
      includeSettlementDateFlows_(includeSettlementDateFlows) {
    registerWith(discountCurve);
}

Member Function Documentation

calculate()

void calculate ( ) const

override

Definition at line 40 of file indexcdstrancheengine.cpp.

                                            {
 
    cpu_timer timer;
    timer.start();
 
    // Upfront premium
    results_.upfrontPremiumValue = 0.0;
    Real upfrontPremiumAmount = arguments_.upfrontPayment->amount();
    if (arguments_.upfrontPayment && !arguments_.upfrontPayment->hasOccurred(
        discountCurve_->referenceDate(), includeSettlementDateFlows_)) {
        results_.upfrontPremiumValue = upfrontPremiumAmount *
            discountCurve_->discount(arguments_.upfrontPayment->date());
    }
 
    // Accrual rebate
    results_.accrualRebateValue = 0.0;
    if (arguments_.accrualRebate && !arguments_.accrualRebate->hasOccurred(
        discountCurve_->referenceDate(), includeSettlementDateFlows_)) {
        results_.accrualRebateValue = arguments_.accrualRebate->amount() *
            discountCurve_->discount(arguments_.accrualRebate->date());
    }
 
    // Accrual rebate current
    results_.accrualRebateCurrentValue = 0.0;
    if (arguments_.accrualRebateCurrent &&
        !arguments_.accrualRebateCurrent->hasOccurred(discountCurve_->referenceDate(), includeSettlementDateFlows_)) {
        results_.accrualRebateCurrentValue =
            discountCurve_->discount(arguments_.accrualRebateCurrent->date()) * arguments_.accrualRebateCurrent->amount();
    }
 
    // Final results, not updated below.
    // FD TODO: check again when testing tranches with existing losses.
    const auto& basket = arguments_.basket;
    QL_REQUIRE(basket, "IndexCdsTrancheEngine expects a non-null basket.");
    results_.xMin = basket->attachmentAmount();
    results_.xMax = basket->detachmentAmount();
    results_.remainingNotional = results_.xMax - results_.xMin;
 
    // Record the expected tranche loss up to inception and up to the end of each coupon period.
    // FD TODO: Recheck 0's for past coupons when testing tranches with existing losses. The loss model gives 
    //          accumulated losses so we should in theory be able to use these.
    vector<Real>& etls = results_.expectedTrancheLoss;
    etls.push_back(0.0);
 
    // Variables used in the loop below.
    Date today = Settings::instance().evaluationDate();
    results_.premiumValue = 0.0;
    results_.protectionValue = 0.0;
    Real inceptionTrancheNotional = arguments_.basket->trancheNotional();
 
    // Value the premium and protection leg.
    for (Size i = 0; i < arguments_.normalizedLeg.size(); i++) {
 
        // Zero expected loss on coupon end dates that have already occured.
        // FD TODO: check again when testing tranches with existing losses.
        if (arguments_.normalizedLeg[i]->hasOccurred(today)) {
            etls.push_back(0.0);
            continue;
        }
 
        QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(arguments_.normalizedLeg[i]);
        QL_REQUIRE(coupon, "IndexCdsTrancheEngine expects leg to have Coupon cashflow type.");
 
        // Relevant dates with assumption that future defaults occur at midpoint of (remaining) coupon period.
        Date paymentDate = coupon->date();
        Date startDate = std::max(coupon->accrualStartDate(), today);
        Date endDate = coupon->accrualEndDate();
        Date defaultDate = startDate + (endDate - startDate) / 2;
 
        // Expected loss on the tranche up to the end of the current period.
        Real etl = basket->expectedTrancheLoss(endDate, arguments_.recoveryRate);
 
        // Update protection leg value
        results_.protectionValue += discountCurve_->discount(defaultDate) * (etl - etls.back());
 
        // Update the premium leg value. If settling accruals, which is standard, assume that losses are evenly 
        // distributed over the coupon period, as per Andersen, Sidenius, Basu Nov 2003 paper for example. If not 
        // settling accruals, just use the tranche notional at period end.
        Real effNtl = 0.0;
        if (arguments_.settlesAccrual) {
            effNtl = inceptionTrancheNotional - (etl + etls.back()) / 2.0;
        } else {
            effNtl = inceptionTrancheNotional - etl;
        }
        results_.premiumValue += (coupon->amount() / inceptionTrancheNotional) *
            effNtl * discountCurve_->discount(paymentDate);
 
        // Update the expected tranche loss results vector.
        etls.push_back(etl);
    }
 
    // Apply correct sign to each PV'ed quantity depending on whether buying or selling protection on the tranche.
    if (arguments_.side == Protection::Buyer) {
        results_.premiumValue *= -1;
        results_.upfrontPremiumValue *= -1;
        upfrontPremiumAmount *= -1;
    } else {
        results_.protectionValue *= -1;
        results_.accrualRebateValue *= -1;
        results_.accrualRebateCurrentValue *= -1;
    }
 
    // Final tranche NPV.
    results_.value = results_.premiumValue + results_.protectionValue +
        results_.upfrontPremiumValue + results_.accrualRebateValue;
 
    // Fair tranche spread.
    Real fairSpread = 0.0;
    if (results_.premiumValue != 0.0) {
        fairSpread = -(results_.protectionValue + results_.upfrontPremiumValue) *
                     arguments_.runningRate / (results_.premiumValue + results_.accrualRebateValue);
    }
 
    timer.stop();
 
    // Populate the additional results.
    results_.additionalResults["attachment"] = arguments_.basket->attachmentRatio();
    results_.additionalResults["detachment"] = arguments_.basket->detachmentRatio();
    results_.additionalResults["fixedRate"] = arguments_.runningRate;
    results_.additionalResults["fairSpread"] = fairSpread;
    results_.additionalResults["upfrontPremium"] = upfrontPremiumAmount;
    Real correlation = arguments_.basket->correlation();
    if (correlation != Null<Real>())
        results_.additionalResults["correlation"] = correlation;
    results_.additionalResults["upfrontPremiumNPV"] = results_.upfrontPremiumValue;
    results_.additionalResults["premiumLegNPV"] = results_.premiumValue;
    results_.additionalResults["accrualRebateNPV"] = results_.accrualRebateValue;
    results_.additionalResults["accrualRebateCurrentNPV"] = results_.accrualRebateCurrentValue;
 
    results_.additionalResults["protectionLegNPV"] = results_.protectionValue;
    results_.additionalResults["calculationTime"] = timer.elapsed().wall * 1e-9;
}

Member Data Documentation

discountCurve_

QuantLib::Handle<QuantLib::YieldTermStructure> discountCurve_

protected

Definition at line 60 of file indexcdstrancheengine.hpp.

includeSettlementDateFlows_

boost::optional<bool> includeSettlementDateFlows_

protected

Definition at line 61 of file indexcdstrancheengine.hpp.