DiscountingBondTRSEngine Class Reference

Discounting Bond TRS Engine. More...

#include <qle/pricingengines/discountingbondtrsengine.hpp>

Inheritance diagram for DiscountingBondTRSEngine:

Collaboration diagram for DiscountingBondTRSEngine:

Public Member Functions
	DiscountingBondTRSEngine (const Handle< YieldTermStructure > &discountCurve)
void	calculate () const override
const Handle< YieldTermStructure > &	discountCurve () const

Private Member Functions
Real	calculateBondNpv (const Date &npvDate, const Date &start, const Date &end, const Handle< YieldTermStructure > &discountCurve) const

Private Attributes
const Handle< YieldTermStructure >	discountCurve_

Detailed Description

Discounting Bond TRS Engine.

Definition at line 40 of file discountingbondtrsengine.hpp.

Constructor & Destructor Documentation

DiscountingBondTRSEngine()

DiscountingBondTRSEngine

(

const Handle< YieldTermStructure > &

discountCurve

)

Definition at line 46 of file discountingbondtrsengine.cpp.

    : discountCurve_(discountCurve) {
    registerWith(discountCurve_);
}

Member Function Documentation

calculate()

void calculate ( ) const

override

Definition at line 51 of file discountingbondtrsengine.cpp.

                                               {
 
    Date today = Settings::instance().evaluationDate();
 
    Handle<Quote> bondSpread = arguments_.bondIndex->securitySpread();
    Handle<Quote> bondRecoveryRate = arguments_.bondIndex->recoveryRate();
    Handle<YieldTermStructure> bondReferenceYieldCurve =
        bondSpread.empty() ? arguments_.bondIndex->discountCurve()
                           : Handle<YieldTermStructure>(QuantLib::ext::make_shared<ZeroSpreadedTermStructure>(
                                 arguments_.bondIndex->discountCurve(), bondSpread));
    QuantLib::ext::shared_ptr<DefaultProbabilityTermStructure> bondDefaultCurve =
        arguments_.bondIndex->defaultCurve().empty()
            ? QuantLib::ext::make_shared<QuantLib::FlatHazardRate>(today, 0.0, Actual365Fixed())
            : arguments_.bondIndex->defaultCurve().currentLink();
    Rate recoveryVal =
        arguments_.bondIndex->recoveryRate().empty() ? 0.0 : arguments_.bondIndex->recoveryRate()->value();
 
    // 1 initialise additional result vectors
 
    std::vector<QuantExt::CashFlowResults> cfResults;
    std::vector<Date> returnStartDates, returnEndDates;
    std::vector<Real> returnFxStarts, returnFxEnds, returnBondStarts, returnBondEnds, returnBondNotionals;
    std::vector<Date> bondCashflowOriginalPayDates, bondCashflowReturnPayDates, bondCashflowFxFixingDate;
    std::vector<Real> bondCashflows, bondCashflowFxRate, bondCashflowSurvivalProbability;
 
    // 2 do some checks on data
 
    QL_REQUIRE(!discountCurve_.empty(), "discounting term structure handle is empty");
    QL_REQUIRE(!arguments_.bondIndex->conditionalOnSurvival(),
               "DiscountingBondTRSEngine::calculate(): bondIndex should not be computed with conditionalOnSurvival = "
               "true in this engine");
 
    Real mult = arguments_.payTotalReturnLeg ? -1.0 : 1.0;
 
    // 3 handle funding leg(s) (leg #2, 3, ...)
 
    Real fundingLeg = 0.0;
    Size fundingLegNo = 2;
    for (auto const& l : arguments_.fundingLeg) {
        fundingLeg += CashFlows::npv(l, **discountCurve_, false);
        for (auto const& c : l) {
            if (c->hasOccurred(today))
                continue;
            cfResults.emplace_back();
            cfResults.back().amount = -mult * c->amount();
            cfResults.back().payDate = c->date();
            cfResults.back().currency = ccyStr(arguments_.fundingCurrency);
            cfResults.back().legNumber = fundingLegNo;
            cfResults.back().type = "Funding";
            if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(c)) {
                cfResults.back().rate = cpn->rate();
                cfResults.back().accrualPeriod = cpn->accrualPeriod();
                cfResults.back().accrualStartDate = cpn->accrualStartDate();
                cfResults.back().accrualEndDate = cpn->accrualEndDate();
                cfResults.back().accruedAmount = cpn->accruedAmount(today);
                cfResults.back().notional = cpn->nominal();
            }
            if (auto cpn = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(c)) {
                cfResults.back().fixingDate = cpn->fixingDate();
                cfResults.back().fixingValue = cpn->index()->fixing(cpn->fixingDate());
            }
        }
        ++fundingLegNo;
    }
 
    // 4 handle total return leg (leg #0)
 
    Real returnLeg = CashFlows::npv(arguments_.returnLeg, **discountCurve_, false);
 
    for (auto const& c : arguments_.returnLeg) {
        if (c->hasOccurred(today))
            continue;
        cfResults.emplace_back();
        cfResults.back().amount = mult * c->amount();
        cfResults.back().payDate = c->date();
        cfResults.back().currency = ccyStr(arguments_.fundingCurrency);
        cfResults.back().legNumber = 0;
        cfResults.back().type = "Return";
        if (auto bc = QuantLib::ext::dynamic_pointer_cast<BondTRSCashFlow>(c)) {
            cfResults.back().fixingDate = bc->fixingEndDate();
            cfResults.back().fixingValue = bc->assetEnd();
            cfResults.back().accrualStartDate = bc->fixingStartDate();
            cfResults.back().accrualEndDate = bc->fixingEndDate();
            cfResults.back().notional = bc->notional();
            returnStartDates.push_back(bc->fixingStartDate());
            returnEndDates.push_back(bc->fixingEndDate());
            returnFxStarts.push_back(bc->fxStart());
            returnFxEnds.push_back(bc->fxEnd());
            returnBondStarts.push_back(bc->assetStart());
            returnBondEnds.push_back(bc->assetEnd());
            returnBondNotionals.push_back(bc->notional());
        }
    }
 
    // 5 handle bond cashflows (leg #1)
 
    QuantLib::ext::shared_ptr<Bond> bd = arguments_.bondIndex->bond();
 
    Date start = bd->settlementDate(arguments_.valuationDates.front());
    Date end = bd->settlementDate(arguments_.valuationDates.back());
 
    Real bondPayments = 0.0, bondRecovery = 0.0;
    bool hasLiveCashFlow = false;
    Size numCoupons = 0;
 
    
 
    for (Size i = 0; i < bd->cashflows().size(); i++) {
 
        // 5a skip bond cashflows that are outside the total return valuation schedule
 
        if (bd->cashflows()[i]->date() <= start || bd->cashflows()[i]->date() > end)
            continue;
 
        // 5b determine bond cf pay date
 
        Date bondFlowPayDate;
        Date bondFlowValuationDate;
        bool paymentAfterMaturityButWithinBondSettlement =
            bd->cashflows()[i]->date() > arguments_.valuationDates.back() && bd->cashflows()[i]->date() <= end;
        if (arguments_.payBondCashFlowsImmediately || paymentAfterMaturityButWithinBondSettlement) {
            bondFlowPayDate = bd->cashflows()[i]->date();
            bondFlowValuationDate = bd->cashflows()[i]->date();
        } else {
            const auto& payDates = arguments_.paymentDates;
            auto nextPayDate = std::lower_bound(payDates.begin(), payDates.end(), bd->cashflows()[i]->date());
            QL_REQUIRE(nextPayDate != payDates.end(), "DiscountingBondTRSEngine::calculate(): unexpected, could "
                                                      "not determine next pay date for bond cashflow date "
                                                          << bd->cashflows()[i]);
            bondFlowPayDate = *nextPayDate;
 
            const auto& valDates = arguments_.valuationDates;
            auto nextValDate = std::upper_bound(valDates.begin(), valDates.end(), bondFlowPayDate);
 
            if (nextValDate == valDates.begin()) {
                nextValDate = valDates.end();
            } else {
                nextValDate--;
            }
 
            QL_REQUIRE(nextValDate != valDates.end(), "DiscountingBondTRSEngine::calculate(): unexpected, could "
                                                      "not determine next valuation date for bond cashflow date "
                                                          << bondFlowPayDate);
            bondFlowValuationDate = *nextValDate;
        }
 
        // 5c skip cashflows that are paid <= today
 
        if (bondFlowPayDate <= today)
            continue;
 
        hasLiveCashFlow = true;
 
        // 5d determine survivial prob S and fx conversion rate for bond cashflow
 
        Probability S = bondDefaultCurve->survivalProbability(bondFlowPayDate);
        // FIXME which fixing date should we use for the fx conversion
        Date fxFixingDate = bondFlowValuationDate;
        if (arguments_.fxIndex)
            fxFixingDate = arguments_.fxIndex->fixingCalendar().adjust(fxFixingDate, Preceding);
        Real fx = arguments_.fxIndex ? arguments_.fxIndex->fixing(fxFixingDate) : 1.0;
 
        // 5e set bond cashflow and additional results
 
        cfResults.emplace_back();
        cfResults.back().amount = mult * bd->cashflows()[i]->amount() * fx * arguments_.bondNotional;
        cfResults.back().discountFactor = discountCurve_->discount(bondFlowPayDate) * S;
        cfResults.back().payDate = bondFlowPayDate;
        cfResults.back().currency = ccyStr(arguments_.fundingCurrency);
        cfResults.back().legNumber = 1;
        cfResults.back().type = "BondCashFlowReturn";
        if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(bd->cashflows()[i])) {
            cfResults.back().rate = cpn->rate();
            cfResults.back().accrualPeriod = cpn->accrualPeriod();
            cfResults.back().accrualStartDate = cpn->accrualStartDate();
            cfResults.back().accrualEndDate = cpn->accrualEndDate();
            cfResults.back().accruedAmount = cpn->accruedAmount(today);
            cfResults.back().notional = cpn->nominal();
        }
        if (auto cpn = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(bd->cashflows()[i])) {
            cfResults.back().fixingDate = cpn->fixingDate();
            cfResults.back().fixingValue = cpn->index()->fixing(cpn->fixingDate());
        }
 
        bondCashflows.push_back(mult * bd->cashflows()[i]->amount() * arguments_.bondNotional);
        bondCashflowOriginalPayDates.push_back(bd->cashflows()[i]->date());
        bondCashflowReturnPayDates.push_back(bondFlowPayDate);
        bondCashflowFxRate.push_back(fx);
        bondCashflowFxFixingDate.push_back(fxFixingDate);
        bondCashflowSurvivalProbability.push_back(S);
 
        // 5f bond cashflow npv contribution
 
        // Real spreadFactor = exp(- bondSpread->value() * discountCurve_->timeFromReference(bondFlowPayDate));
        bondPayments +=
            bd->cashflows()[i]->amount() * S * discountCurve_->discount(bondFlowPayDate) * fx; // * spreadFactor;
 
        // 5g bond cashflow recovery contribution
 
        if (auto coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(bd->cashflows()[i])) {
            Date startDate = coupon->accrualStartDate();
            Date endDate = coupon->accrualEndDate();
            Date effectiveStartDate = (startDate <= start && start <= endDate) ? start : startDate;
            if (effectiveStartDate < today)
                effectiveStartDate = today;
            if (endDate > effectiveStartDate) {
                Probability P = bondDefaultCurve->defaultProbability(effectiveStartDate, endDate);
                Date defaultDate = effectiveStartDate + (endDate - effectiveStartDate) / 2;
                // FIXME which fixing date should we use for the fx conversion?
                Real fx = arguments_.fxIndex ? arguments_.fxIndex->fixing(arguments_.fxIndex->fixingCalendar().adjust(
                                                   coupon->date(), Preceding))
                                             : 1.0;
                bondRecovery += coupon->nominal() * recoveryVal * P * discountCurve_->discount(defaultDate) * fx;
            }
            ++numCoupons;
        }
 
    } // loop over bond cashflows
 
    // 5h multiply bond payments and recovery contributions by bond notional
    bondPayments *= arguments_.bondNotional;
    bondRecovery *= arguments_.bondNotional;
 
    // 5i bond recovery value (special treatment for zero bonds)
 
    if (hasLiveCashFlow) {
        if (bd->cashflows().size() > 1 && numCoupons == 0) {
            QL_FAIL("DiscountingBondTRSEngine: no support of bonds with multiple cashflows but no coupons");
        }
        /* If there are no coupon, as in a Zero Bond, we must integrate over the entire period from npv date to
           maturity. The timestepPeriod specified is used as provide the steps for the integration. This only
           applies to bonds with 1 cashflow, identified as a final redemption payment. */
        if (bd->cashflows().size() == 1) {
            QuantLib::ext::shared_ptr<Redemption> redemption = QuantLib::ext::dynamic_pointer_cast<Redemption>(bd->cashflows()[0]);
            if (redemption) {
                Date startDate = (start < today ? today : start);
                while (startDate < redemption->date()) {
                    Date stepDate = startDate + 1 * Months; // hardcoded period
                    Date endDate = (stepDate > redemption->date()) ? redemption->date() : stepDate;
                    Date defaultDate = startDate + (endDate - startDate) / 2;
                    Probability P = bondDefaultCurve->defaultProbability(startDate, endDate);
                    // FIXME which fixing date should we use for the fx conversion?
                    Real fx = arguments_.fxIndex
                                  ? arguments_.fxIndex->fixing(
                                        arguments_.fxIndex->fixingCalendar().adjust(redemption->date(), Preceding))
                                  : 1.0;
                    bondRecovery += redemption->amount() * recoveryVal * P * discountCurve_->discount(defaultDate) * fx;
                    startDate = stepDate;
                }
            }
        }
    }
 
    // 6 set results
 
    results_.value = mult * (returnLeg + bondPayments + bondRecovery - fundingLeg);
 
    results_.additionalResults["returnLegNpv"] = mult * (returnLeg + bondPayments + bondRecovery);
    results_.additionalResults["returnLegNpvReturnPaymentsContribtion"] = mult * returnLeg;
    results_.additionalResults["returnLegNpvBondPaymentsContribtion"] = mult * bondPayments;
    results_.additionalResults["returnLegNpvBondRecoveryContribution"] = mult * bondRecovery;
    results_.additionalResults["fundingLegNpv"] = -mult * fundingLeg;
 
    results_.additionalResults["cashFlowResults"] = cfResults;
 
    results_.additionalResults["returnStartDate"] = returnStartDates;
    results_.additionalResults["returnEndDate"] = returnEndDates;
    results_.additionalResults["returnFxStart"] = returnFxStarts;
    results_.additionalResults["returnFxEnd"] = returnFxEnds;
    results_.additionalResults["returnBondStart"] = returnBondStarts;
    results_.additionalResults["returnBondEnd"] = returnBondEnds;
 
    results_.additionalResults["bondCashflow"] = bondCashflows;
    results_.additionalResults["bondCashflowOriginalPayDate"] = bondCashflowOriginalPayDates;
    results_.additionalResults["bondCashflowReturnPayDate"] = bondCashflowReturnPayDates;
    results_.additionalResults["bondCashflowFxRate"] = bondCashflowFxRate;
    results_.additionalResults["bondCashflowFxFixingDate"] = bondCashflowFxFixingDate;
    results_.additionalResults["bondCashflowSurvivalProbability"] = bondCashflowSurvivalProbability;
 
    results_.additionalResults["bondNotional"] = returnBondNotionals;
    results_.additionalResults["bondCurrency"] = ccyStr(arguments_.bondCurrency);
    results_.additionalResults["returnCurrency"] = ccyStr(arguments_.fundingCurrency);
 
    results_.additionalResults["bondCleanPrice"] = arguments_.bondIndex->bond()->cleanPrice();
    results_.additionalResults["bondDirtyPrice"] = arguments_.bondIndex->bond()->dirtyPrice();
    results_.additionalResults["bondSpread"] = bondSpread->value();
    results_.additionalResults["bondRecovery"] = recoveryVal;
}

Here is the call graph for this function:

discountCurve()

const Handle< YieldTermStructure > & discountCurve

(

)

const

Definition at line 46 of file discountingbondtrsengine.hpp.

{ return discountCurve_; }

calculateBondNpv()

Real calculateBondNpv ( const Date &  npvDate, const Date &  start, const Date &  end, const Handle< YieldTermStructure > &  discountCurve  ) const

private

Member Data Documentation

discountCurve_

const Handle<YieldTermStructure> discountCurve_

private

Definition at line 52 of file discountingbondtrsengine.hpp.