MidPointCDOEngine Class Reference

CDO base engine taking schedule steps. More...

#include <qle/pricingengines/midpointcdoengine.hpp>

Inheritance diagram for MidPointCDOEngine:

Collaboration diagram for MidPointCDOEngine:

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

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

Detailed Description

CDO base engine taking schedule steps.

Definition at line 44 of file midpointcdoengine.hpp.

Constructor & Destructor Documentation

MidPointCDOEngine()

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

Definition at line 46 of file midpointcdoengine.hpp.

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

Member Function Documentation

calculate()

void calculate ( ) const

override

Definition at line 31 of file midpointcdoengine.cpp.

                                        {
 
    cpu_timer timer;
    timer.start();
 
    Date today = Settings::instance().evaluationDate();
 
    results_.premiumValue = 0.0;
    results_.protectionValue = 0.0;
    results_.upfrontPremiumValue = 0.0;
    results_.error = 0;
    results_.expectedTrancheLoss.clear();
    // todo Should be remaining when considering realized loses
    results_.xMin = arguments_.basket->attachmentAmount();
    results_.xMax = arguments_.basket->detachmentAmount();
    results_.remainingNotional = results_.xMax - results_.xMin;
    const Real inceptionTrancheNotional = arguments_.basket->trancheNotional();
 
    // Upfront Flow NPV and accrual rebate NPV. Either we are on-the-run (no flow)
    // or we are forward start
 
    // date determining the probability survival so we have to pay
    // the upfront flows (did not knock out)
    Date refDate = discountCurve_->referenceDate();
    // Date effectiveProtectionStart = arguments_.protectionStart > refDate ? arguments_.protectionStart : refDate ;
    Probability nonKnockOut = 1.0; // FIXME
 
    Real upfPVO1 = 0.0;
    results_.upfrontPremiumValue = 0.0;
    if (arguments_.upfrontPayment && !arguments_.upfrontPayment->hasOccurred(refDate, includeSettlementDateFlows_)) {
        upfPVO1 = nonKnockOut * discountCurve_->discount(arguments_.upfrontPayment->date());
        results_.upfrontPremiumValue = upfPVO1 * arguments_.upfrontPayment->amount();
    }
 
    results_.accrualRebateValue = 0.;
    if (arguments_.accrualRebate && !arguments_.accrualRebate->hasOccurred(refDate, includeSettlementDateFlows_)) {
        results_.accrualRebateValue = nonKnockOut * discountCurve_->discount(arguments_.accrualRebate->date()) *
                                      arguments_.accrualRebate->amount();
    }
 
    // compute expected loss at the beginning of first relevant period
    Real zeroRecovery_e1 = 0, recovery_e1 = 0;
    // todo add includeSettlement date flows variable to engine.
    // RL: comment the following out, thows a negative time error
    // if (!arguments_.normalizedLeg[0]->hasOccurred(today))
    //     // Notice that since there might be a gap between the end of
    //     // acrrual and payment dates and today be in between
    //     // the tranche loss on that date might not be contingent but
    //     // realized:
    //     e1 = arguments_.basket->expectedTrancheLoss(
    //         QuantLib::ext::dynamic_pointer_cast<Coupon>(
    //             arguments_.normalizedLeg[0])->accrualStartDate());
    results_.expectedTrancheLoss.push_back(recovery_e1);
    //'e1'  should contain the existing loses.....? use remaining amounts?
    for (Size i = 0; i < arguments_.normalizedLeg.size(); i++) {
        if (arguments_.normalizedLeg[i]->hasOccurred(today)) {
            results_.expectedTrancheLoss.push_back(0.);
            continue;
        }
        QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(arguments_.normalizedLeg[i]);
        Date paymentDate = coupon->date();
        Date startDate = std::max(coupon->accrualStartDate(), discountCurve_->referenceDate());
        Date endDate = coupon->accrualEndDate();
        // we assume the loss within the period took place on this date:
        Date defaultDate = startDate + (endDate - startDate) / 2;
 
        Real zeroRecovery_e2 =
            arguments_.basket->expectedTrancheLoss(endDate, true); // zero recoveries for the coupon leg
 
        Real recovery_e2 =
            arguments_.basket->expectedTrancheLoss(endDate, false); // non-zero recovery for the default leg
 
        results_.expectedTrancheLoss.push_back(recovery_e2);
        results_.premiumValue += ((inceptionTrancheNotional - zeroRecovery_e2) / inceptionTrancheNotional) *
                                 coupon->amount() * discountCurve_->discount(paymentDate);
 
        // default flows:
        Date protectionPaymentDate;
        if (arguments_.protectionPaymentTime == CreditDefaultSwap::ProtectionPaymentTime::atDefault) {
            protectionPaymentDate = defaultDate;
        } else if (arguments_.protectionPaymentTime == CreditDefaultSwap::ProtectionPaymentTime::atPeriodEnd) {
            protectionPaymentDate = paymentDate;
        } else if (arguments_.protectionPaymentTime == CreditDefaultSwap::ProtectionPaymentTime::atMaturity) {
            protectionPaymentDate = arguments_.maturity;
        } else {
            QL_FAIL("protectionPaymentTime not handled");
        }
        const Real discount = discountCurve_->discount(protectionPaymentDate);
 
        // Accrual removed till the argument flag is implemented
        // pays accrued on defaults' date
        if (arguments_.settlesAccrual)
            results_.premiumValue += coupon->accruedAmount(defaultDate) * discount *
                                     (zeroRecovery_e2 - zeroRecovery_e1) / inceptionTrancheNotional;
 
        results_.protectionValue += discount * (recovery_e2 - recovery_e1);
        /* use it in a future version for coherence with the integral engine
         * arguments_.leverageFactor;
         */
        recovery_e1 = recovery_e2;
        zeroRecovery_e1 = zeroRecovery_e2;
    }
 
    /* use it in a future version for coherence with the integral engine
        arguments_.leverageFactor * ;
    */
    if (arguments_.side == Protection::Buyer) {
        results_.premiumValue *= -1;
        results_.upfrontPremiumValue *= -1;
    } else {
        results_.protectionValue *= -1;
        results_.accrualRebateValue *= -1;
    }
    results_.value =
        results_.premiumValue + results_.protectionValue + results_.upfrontPremiumValue + results_.accrualRebateValue;
    results_.errorEstimate = Null<Real>();
    // Fair spread GIVEN the upfront
    Real fairSpread = 0.;
    if (results_.premiumValue != 0.0) {
        fairSpread = -(results_.protectionValue + results_.upfrontPremiumValue + results_.accrualRebateValue) *
                     arguments_.runningRate / results_.premiumValue;
    }
 
    timer.stop();
 
    results_.additionalResults["attachment"] = arguments_.basket->attachmentRatio();
    results_.additionalResults["detachment"] = arguments_.basket->detachmentRatio();
    results_.additionalResults["fixedRate"] = arguments_.runningRate;
    results_.additionalResults["fairSpread"] = fairSpread;
    results_.additionalResults["upfrontPremium"] = arguments_.upfrontPayment->amount();
    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["protectionLegNPV"] = results_.protectionValue;
    results_.additionalResults["calculationTime"] = timer.elapsed().wall * 1e-9;
}

Member Data Documentation

discountCurve_

Handle<YieldTermStructure> discountCurve_

protected

Definition at line 54 of file midpointcdoengine.hpp.

includeSettlementDateFlows_

boost::optional<bool> includeSettlementDateFlows_

protected

Definition at line 55 of file midpointcdoengine.hpp.