Serializable CDS Index Tranche (Synthetic CDO) More...

#include <ored/portfolio/cdo.hpp>

Inheritance diagram for SyntheticCDO:

Collaboration diagram for SyntheticCDO:

Public Member Functions
	SyntheticCDO ()

	SyntheticCDO (const Envelope &env, const LegData &leg, const string &qualifier, const BasketData &basketData, double attachmentPoint, double detachmentPoint, const bool settlesAccrual=true, const QuantExt::CreditDefaultSwap::ProtectionPaymentTime protectionPaymentTime=QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault, const string &protectionStart=string(), const string &upfrontDate=string(), const Real upfrontFee=Null< Real >(), const bool rebatesAccrual=true, Real recoveryRate=Null< Real >())

virtual void	build (const QuantLib::ext::shared_ptr< EngineFactory > &) override

const string &	qualifier () const
	Inspectors. More...

const LegData &	leg () const

const BasketData &	basketData () const

const double &	attachmentPoint () const

const double &	detachmentPoint () const

QuantExt::CreditDefaultSwap::ProtectionPaymentTime	protectionPaymentTime () const

const string &	protectionStart () const

const string &	upfrontDate () const

const double &	upfrontFee () const

bool	settlesAccrual () const

bool	rebatesAccrual () const

const Real &	recoveryRate () const

bool	useSensitivitySimplification () const

const std::map< std::string, Real > &	basketConstituents () const

virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

std::string	creditCurveIdWithTerm () const

void	setIndexStartDateHint (const QuantLib::Date &d) const

const QuantLib::Date &	indexStartDateHint () const

Public Member Functions inherited from Trade
	Trade ()
	Default constructor. More...

	Trade (const string &tradeType, const Envelope &env=Envelope(), const TradeActions &ta=TradeActions())
	Base class constructor. More...

virtual	~Trade ()
	Default destructor. More...

virtual void	build (const QuantLib::ext::shared_ptr< EngineFactory > &)=0

virtual std::map< std::string, RequiredFixings::FixingDates >	fixings (const QuantLib::Date &settlementDate=QuantLib::Date()) const

const RequiredFixings &	requiredFixings () const

virtual std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const

void	reset ()
	Reset trade, clear all base class data. This does not reset accumulated timings for this trade. More...

void	resetPricingStats (const std::size_t numberOfPricings=0, const boost::timer::nanosecond_type cumulativePricingTime=0)
	Reset accumulated timings to given values. More...

string &	id ()
	Set the trade id. More...

void	setEnvelope (const Envelope &envelope)
	Set the envelope with counterparty and portfolio info. More...

void	setAdditionalData (const std::map< std::string, boost::any > &additionalData)

TradeActions &	tradeActions ()
	Set the trade actions. More...

const string &	id () const

const string &	tradeType () const

const Envelope &	envelope () const

const set< string > &	portfolioIds () const

const TradeActions &	tradeActions () const

const QuantLib::ext::shared_ptr< InstrumentWrapper > &	instrument () const

const std::vector< QuantLib::Leg > &	legs () const

const std::vector< string > &	legCurrencies () const

const std::vector< bool > &	legPayers () const

const string &	npvCurrency () const

virtual QuantLib::Real	notional () const
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...

virtual string	notionalCurrency () const

const Date &	maturity () const

virtual bool	isExpired (const Date &d)

const string &	issuer () const

template<typename T >
T	additionalDatum (const std::string &tag) const
	returns any additional datum. More...

virtual const std::map< std::string, boost::any > &	additionalData () const
	returns all additional data returned by the trade once built More...

const std::string &	sensitivityTemplate () const

void	validate () const
	Utility to validate that everything that needs to be set in this base class is actually set. More...

virtual bool	hasCashflows () const

boost::timer::nanosecond_type	getCumulativePricingTime () const
	Get cumulative timing spent on pricing. More...

std::size_t	getNumberOfPricings () const
	Get number of pricings. More...

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

virtual XMLNode *	toXML (XMLDocument &doc) const =0

void	fromFile (const std::string &filename)

void	toFile (const std::string &filename) const

void	fromXMLString (const std::string &xml)
	Parse from XML string. More...

std::string	toXMLString () const
	Parse from XML string. More...

Static Public Member Functions
static vector< Time >	extractTimeGridDefaultCurve (const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &dpts)

static QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure >	buildCalibratedConstiuentCurve (const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &curve, const QuantLib::ext::shared_ptr< SimpleQuote > &calibrationFactor)

Private Member Functions
bool	isIndexTranche () const

Private Attributes
string	qualifier_

LegData	legData_

BasketData	basketData_

double	attachmentPoint_

double	detachmentPoint_

bool	settlesAccrual_

QuantExt::CreditDefaultSwap::ProtectionPaymentTime	protectionPaymentTime_

string	protectionStart_

string	upfrontDate_

double	upfrontFee_

bool	rebatesAccrual_

Real	recoveryRate_

std::map< std::string, double >	basketConstituents_

bool	useSensitivitySimplification_

QuantLib::Date	indexStartDateHint_

Additional Inherited Members
Protected Member Functions inherited from Trade
Date	addPremiums (std::vector< QuantLib::ext::shared_ptr< Instrument > > &instruments, std::vector< Real > &multipliers, const Real tradeMultiplier, const PremiumData &premiumData, const Real premiumMultiplier, const Currency &tradeCurrency, const QuantLib::ext::shared_ptr< EngineFactory > &factory, const string &configuration)

void	setLegBasedAdditionalData (const Size legNo, Size resultLegId=Null< Size >()) const

void	setSensitivityTemplate (const EngineBuilder &builder)

void	setSensitivityTemplate (const std::string &id)

Protected Attributes inherited from Trade
string	tradeType_

QuantLib::ext::shared_ptr< InstrumentWrapper >	instrument_

std::vector< QuantLib::Leg >	legs_

std::vector< string >	legCurrencies_

std::vector< bool >	legPayers_

string	npvCurrency_

QuantLib::Real	notional_

string	notionalCurrency_

Date	maturity_

string	issuer_

string	sensitivityTemplate_

bool	sensitivityTemplateSet_ = false

std::size_t	savedNumberOfPricings_ = 0

boost::timer::nanosecond_type	savedCumulativePricingTime_ = 0

RequiredFixings	requiredFixings_

std::map< std::string, boost::any >	additionalData_

Detailed Description

Serializable CDS Index Tranche (Synthetic CDO)

Definition at line 40 of file cdo.hpp.

Constructor & Destructor Documentation

◆ SyntheticCDO() [1/2]

SyntheticCDO ( )

Definition at line 42 of file cdo.hpp.

                 : Trade("SyntheticCDO"),
           attachmentPoint_(Null<Real>()), detachmentPoint_(Null<Real>()), settlesAccrual_(true),
           protectionPaymentTime_(QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault),
           upfrontFee_(Null<Real>()), rebatesAccrual_(true), recoveryRate_(Null<Real>()),
           useSensitivitySimplification_(false) {}

◆ SyntheticCDO() [2/2]

SyntheticCDO	(	const Envelope &	env,
		const LegData &	leg,
		const string &	qualifier,
		const BasketData &	basketData,
		double	attachmentPoint,
		double	detachmentPoint,
		const bool	settlesAccrual = `true`,
		const QuantExt::CreditDefaultSwap::ProtectionPaymentTime	protectionPaymentTime = `QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault`,
		const string &	protectionStart = `string()`,
		const string &	upfrontDate = `string()`,
		const Real	upfrontFee = `Null<Real>()`,
		const bool	rebatesAccrual = `true`,
		Real	recoveryRate = `Null<Real>()`
	)

Definition at line 47 of file cdo.hpp.

        : Trade("SyntheticCDO", env), qualifier_(qualifier), legData_(leg), basketData_(basketData),
          attachmentPoint_(attachmentPoint), detachmentPoint_(detachmentPoint), settlesAccrual_(settlesAccrual),
          protectionPaymentTime_(protectionPaymentTime), protectionStart_(protectionStart), upfrontDate_(upfrontDate),
          upfrontFee_(upfrontFee), rebatesAccrual_(rebatesAccrual), recoveryRate_(recoveryRate),
      useSensitivitySimplification_(false) {}

Here is the call graph for this function:

Member Function Documentation

◆ build()

void build ( const QuantLib::ext::shared_ptr< EngineFactory > & )

overridevirtual

Build QuantLib/QuantExt instrument, link pricing engine. If build() is called multiple times, reset() should be called between these calls.

Implements Trade.

Definition at line 75 of file cdo.cpp.

                                                                                  {
 
    DLOG("SyntheticCDO::build() called for trade " << id());
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = string("Credit");
    additionalData_["isdaBaseProduct"] = string("Index Tranche");
    QuantLib::ext::shared_ptr<ReferenceDataManager> refData = engineFactory->referenceData();
    if (refData && refData->hasData("CreditIndex", qualifier_)) {
        auto refDatum = refData->getData("CreditIndex", qualifier_);
        QuantLib::ext::shared_ptr<CreditIndexReferenceDatum> creditIndexRefDatum =
            QuantLib::ext::dynamic_pointer_cast<CreditIndexReferenceDatum>(refDatum);
        additionalData_["isdaSubProduct"] = creditIndexRefDatum->indexFamily();
        if (creditIndexRefDatum->indexFamily() == "") {
            ALOG("IndexFamily is blank in credit index reference data for entity " << qualifier_);
        }
    } else {
        ALOG("Credit index reference data missing for entity " << qualifier_ << ", isdaSubProduct left blank");
    }
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = string("");  
 
    Date protectionStartDate = protectionStart_ == "" ? Date() : parseDate(protectionStart_);
    Date upfrontDate = upfrontDate_ == "" ? Date() : parseDate(upfrontDate_);
    Leg leg = makeFixedLeg(legData_);
    Protection::Side side = legData_.isPayer() ? Protection::Buyer : Protection::Seller;
    Schedule schedule = makeSchedule(legData_.schedule());
    Real fixedRecovery = recoveryRate_;
    auto fixedLegData = QuantLib::ext::dynamic_pointer_cast<FixedLegData>(legData_.concreteLegData());
    QL_REQUIRE(fixedLegData, "Expected FixedLegData but got " << legData_.legType());
    Real runningRate = fixedLegData->rates().front();
    DayCounter dayCounter = parseDayCounter(legData_.dayCounter());
    BusinessDayConvention bdc = parseBusinessDayConvention(legData_.paymentConvention());
    Currency ccy = parseCurrency(legData_.currency());
 
    // In general for CDS index trades, the standard day counter is Actual/360 and the final
    // period coupon accrual includes the maturity date.
    Actual360 standardDayCounter;
    DayCounter lastPeriodDayCounter = dayCounter == standardDayCounter ? Actual360(true) : dayCounter;
 
 
    // Set some trade variables
    npvCurrency_ = legData_.currency();
    maturity_ = leg.back()->date();
    notionalCurrency_ = legData_.currency();
    legs_ = {leg};
    legPayers_ = {legData_.isPayer()};
    legCurrencies_ = {legData_.currency()};
 
    // Checks for upfront date and upfront fee
    QL_REQUIRE(upfrontDate == Date() || upfrontFee_ != Null<Real>(),
               "If upfront date is given (" << upfrontDate << "), upfront fee must be given.");
    QL_REQUIRE(upfrontDate != Date() || upfrontFee_ == Null<Real>() || close_enough(upfrontFee_, 0.0),
               "If no upfront date is given, no upfront fee should be given but got " << upfrontFee_ << ".");
 
    // Get the original total notional using the contractual attachment point and detachment point and the contractual
    // tranche notional. We will calculate the corresponding current amounts below from the basket or reference data.
    QL_REQUIRE(attachmentPoint_ < detachmentPoint_, "Detachment point should be greater than attachment point.");
    Real origTrancheNtl = legData_.notionals().front();
    Real origTotalNtl = origTrancheNtl / (detachmentPoint_ - attachmentPoint_);
    Real origEquityNtl = origTotalNtl * attachmentPoint_;
    Real origSeniorNtl = origTotalNtl * (1.0 - detachmentPoint_);
 
    DLOG("Original tranche notional: " << origTrancheNtl);
    DLOG("Original equity notional:  " << origEquityNtl);
    DLOG("Original senior notional:  " << origSeniorNtl);
    DLOG("Original attachment point: " << attachmentPoint_);
    DLOG("Original detachment point: " << detachmentPoint_);
    DLOG("Original total notional:   " << origTotalNtl);
 
    // There may have been credit events up to the valuation date. Record the cumulative lost and recovered notional.
    Real lostNotional = 0.0;
    Real recoveredNotional = 0.0;
    // clear the basketNotionals and credit names
 
    vector<Real> basketNotionals;
 
    vector<string> creditCurves;
 
    
 
    if (basketData_.constituents().size() > 0) {
 
        const auto& constituents = basketData_.constituents();
        DLOG("Building constituents from basket data containing " << constituents.size() << " elements.");
 
        Real totalRemainingNtl = 0.0;
        Real totalPriorNtl = 0.0;
 
        for (const auto& c : constituents) {
            Real ntl = Null<Real>(), priorNotional = Null<Real>();
            const auto& creditCurve = c.creditCurveId();
            if (c.weightInsteadOfNotional()) {
                ntl = c.weight() * origTotalNtl;
                priorNotional = c.priorWeight();
                if (priorNotional != Null<Real>()) {
                    priorNotional *= origTotalNtl;
                }
            } else {
                ntl = c.notional();
                priorNotional = c.priorNotional();
                QL_REQUIRE(c.currency() == npvCurrency_, "The currency of basket constituent "
                                                             << creditCurve << " is " << c.currency()
                                                             << " and does not equal the trade leg currency "
                                                             << npvCurrency_);
            }
 
            if (!close(0.0, ntl) && ntl > 0.0) {
                if (std::find(creditCurves.begin(), creditCurves.end(), creditCurve) == creditCurves.end()) {
                    DLOG("Adding underlying " << creditCurve << " with notional " << ntl);
                    creditCurves.push_back(creditCurve);
                    basketNotionals.push_back(ntl);
                    totalRemainingNtl += ntl;
                } else {
                    StructuredTradeErrorMessage(id(), "Synthetic CDO", "Error building trade",
                                                     ("Invalid Basket: found a duplicate credit curve " + creditCurve +
                                                      ", skip it. Check the basket data for possible errors.")
                                                    .c_str())
                        .log();
                }
            } else {
                DLOG("Underlying " << creditCurve << " notional is " << ntl << " so assuming a credit event occured.");
                QL_REQUIRE(priorNotional != Null<Real>(),
                           "Expecting a valid prior notional for name " << creditCurve << ".");
                auto recovery = c.recovery();
                QL_REQUIRE(recovery != Null<Real>(), "Expecting a valid recovery for name " << creditCurve << ".");
                validateWeightRec(recovery, creditCurve, "recovery");
                lostNotional += (1.0 - recovery) * priorNotional;
                recoveredNotional += recovery * priorNotional;
                totalPriorNtl += priorNotional;
            }
        }
 
        Real totalNtl = totalRemainingNtl + totalPriorNtl;
        DLOG("All Underlyings added, total remaining notional = " << totalRemainingNtl);
        DLOG("All Underlyings added, total prior notional = " << totalPriorNtl);
        DLOG("All Underlyings added, total notional = " << totalNtl);
 
        QL_REQUIRE(creditCurves.size() == basketNotionals.size(), "numbers of defaults curves ("
                                                                      << creditCurves.size() << ") and notionals ("
                                                                      << basketNotionals.size() << ") doesnt match");
        Real notionalCorrectionFactor = origTotalNtl / totalNtl;
        // Scaling to Notional if relative error is close less than 10^-4
        if (!close(totalNtl, origTotalNtl) && (abs(notionalCorrectionFactor - 1.0) <= 1e-4)) {
            ALOG("Trade " << id() << ", sum of notionals(" << totalNtl << ") is very close to total original notional ("
                          << origTotalNtl << "), will scale each notional by " << notionalCorrectionFactor
                          << ",  check the basket data for possible errors.");
            totalRemainingNtl = 0;
            for (Size i = 0; i < basketNotionals.size(); i++) {
                Real scaledNotional = basketNotionals[i] * notionalCorrectionFactor;
                TLOG("Trade " << id() << ", Issuer" << creditCurves[i] << " unscaled Notional: " << basketNotionals[i]
                              << ", scaled Notional: " << scaledNotional);
                basketNotionals[i] = scaledNotional;
                totalRemainingNtl += scaledNotional;
            }
            lostNotional *= notionalCorrectionFactor;
            recoveredNotional *= notionalCorrectionFactor;
            totalNtl *= notionalCorrectionFactor;
        }
 
        if (!close(totalRemainingNtl, origTotalNtl) && totalRemainingNtl > origTotalNtl) {
            StructuredTradeErrorMessage(id(), "Synthetic CDO", "Error building trade",
                                             ("Total remaining notional (" + std::to_string(totalRemainingNtl) +
                                              ") is greater than total original notional (" +
                                              std::to_string(origTotalNtl) +
                                              "),  check the basket data for possible errors.")
                                            .c_str())
                .log();
        }
 
        if (!close(totalNtl, origTotalNtl)) {
            StructuredTradeErrorMessage(id(), "Synthetic CDO", "Error building trade",
                                            ("Expected the total notional (" + std::to_string(totalNtl) + " = " +
                                             std::to_string(totalRemainingNtl) + " + " + std::to_string(totalPriorNtl) +
                                             ") to equal the total original notional (" + std::to_string(origTotalNtl) +
                                             "),  check the basket data for possible errors.")
                                            .c_str())
                .log();
        }
 
        DLOG("Finished building constituents using basket data.");
 
    } else {
 
        DLOG("Building constituents using CreditIndexReferenceDatum for ID " << qualifier_);
 
        QL_REQUIRE(engineFactory->referenceData(),
                   "Trade " << id() << " has no basket data and there is no reference data manager.");
        QL_REQUIRE(engineFactory->referenceData()->hasData(CreditIndexReferenceDatum::TYPE, qualifier_),
                   "Trade " << id() << " needs credit index reference data for ID " << qualifier_);
        auto crd = QuantLib::ext::dynamic_pointer_cast<CreditIndexReferenceDatum>(
            engineFactory->referenceData()->getData(CreditIndexReferenceDatum::TYPE, qualifier_));
 
        Real totalRemainingWeight = 0.0;
        Real totalPriorWeight = 0.0;
        for (const auto& c : crd->constituents()) {
 
            const auto& name = c.name();
            auto weight = c.weight();
            validateWeightRec(weight, name, "weight");
 
            if (!close(0.0, weight)) {
                DLOG("Adding underlying " << name << " with weight " << weight);
                creditCurves.push_back(name);
                basketNotionals.push_back(weight * origTotalNtl);
                totalRemainingWeight += weight;
            } else {
                DLOG("Underlying " << name << " has weight " << weight << " so assuming a credit event occured.");
                auto priorWeight = c.priorWeight();
                QL_REQUIRE(priorWeight != Null<Real>(), "Expecting a valid prior weight for name " << name << ".");
                validateWeightRec(priorWeight, name, "prior weight");
                auto recovery = c.recovery();
                QL_REQUIRE(recovery != Null<Real>(), "Expecting a valid recovery for name " << name << ".");
                validateWeightRec(recovery, name, "recovery");
                lostNotional += (1.0 - recovery) * priorWeight * origTotalNtl;
                recoveredNotional += recovery * priorWeight * origTotalNtl;
                totalPriorWeight += priorWeight;
            }
        }
 
        Real totalWeight = totalRemainingWeight + totalPriorWeight;
        DLOG("All Underlyings added, total remaining weight = " << totalRemainingWeight);
        DLOG("All Underlyings added, total prior weight = " << totalPriorWeight);
        DLOG("All Underlyings added, total weight = " << totalWeight);
 
        if (!close(totalRemainingWeight, 1.0) && totalRemainingWeight > 1.0) {
            ALOG("Total remaining weight is greater than 1, possible error in CreditIndexReferenceDatum");
        }
 
        if (!close(totalWeight, 1.0)) {
            ALOG("Expected the total weight (" << totalWeight << " = " << totalRemainingWeight << " + "
                                               << totalPriorWeight
                                               << ") to equal 1, possible error in CreditIndexReferenceDatum");
        }
 
        DLOG("Finished building constituents using CreditIndexReferenceDatum for ID " << qualifier_);
    }
 
    // Lost notional eats into junior tranches and recovered amount reduces senior tranches.
    // Throw exception if tranche has been completely written down. Should be removed from portfolio or will be
    // ignored if continue on error is true. Maybe better to have instrument that gives an NPV of 0.
    Real currTotalNtl = accumulate(basketNotionals.begin(), basketNotionals.end(), 0.0);
    QL_REQUIRE(!close(currTotalNtl, 0.0), "Trade " << id() << " has a current total notional of 0.0.");
    Real currEquityNtl = max(origEquityNtl - lostNotional, 0.0);
    Real currSeniorNtl = max(origSeniorNtl - recoveredNotional, 0.0);
    Real currTrancheNtl = origTrancheNtl - max(min(recoveredNotional - origSeniorNtl, origTrancheNtl), 0.0) -
                          max(min(lostNotional - origEquityNtl, origTrancheNtl), 0.0);
    QL_REQUIRE(!close(currTrancheNtl, 0.0), "Trade " << id() << " has a current tranche notional of 0.0.");
    Real adjAttachPoint = currEquityNtl / currTotalNtl;
    Real adjDetachPoint = (currEquityNtl + currTrancheNtl) / currTotalNtl;
    notional_ = currTrancheNtl;
 
    DLOG("Current tranche notional: " << currTrancheNtl);
    DLOG("Current equity notional:  " << currEquityNtl);
    DLOG("Current senior notional:  " << currSeniorNtl);
    DLOG("Current attachment point: " << adjAttachPoint);
    DLOG("Current detachment point: " << adjDetachPoint);
    DLOG("Current total notional:   " << currTotalNtl);
 
    
    const auto& market = engineFactory->market();
    auto cdoEngineBuilder = QuantLib::ext::dynamic_pointer_cast<CdoEngineBuilder>(engineFactory->builder("SyntheticCDO"));
    QL_REQUIRE(cdoEngineBuilder, "Trade " << id() << " needs a valid CdoEngineBuilder.");
    const string& config = cdoEngineBuilder->configuration(MarketContext::pricing);
    
    
    std::vector<Handle<DefaultProbabilityTermStructure>> dpts;
    vector<Real> recoveryRates;
 
    if (fixedRecovery != Null<Real>()) {
        LOG("Set all recovery rates to " << fixedRecovery);
    } 
    for (Size i = 0; i < creditCurves.size(); ++i) {
        const string& cc = creditCurves[i];
        Real mktRecoveryRate = market->recoveryRate(cc, config)->value();
        recoveryRates.push_back(fixedRecovery != Null<Real>() ? fixedRecovery : mktRecoveryRate);
        auto originalCurve = market->defaultCurve(cc, config)->curve();
        dpts.push_back(originalCurve);
    }
 
    // TODO check if underlying is index cds
 
    // Calibrate the underlying constituent curves so that the index cds pricing with underlying curves matches the
    // prices of the index cds with flat index curve.
    
    QuantLib::ext::shared_ptr<SimpleQuote> calibrationFactor = QuantLib::ext::make_shared<SimpleQuote>(1.0);
 
    bool calibrateConstiuentCurves = cdoEngineBuilder->calibrateConstituentCurve() && isIndexTranche();
 
    if (calibrateConstiuentCurves) {
        // Adjustment factor is a simplified version of the O'Kane's Forward Default Probability Multiplier 
        // O'Kane 2008 - Modelling Single-name and Multi-name Credit Derivatives
        // Chapter 10.6
        LOG("Use calibrated constiuent curves");
        QuantLib::ext::shared_ptr<IndexCreditDefaultSwap> indexCDS;
        Real cdsFairSpreads = 0.0;
        Real cdsNpvs = 0.0;
        try {
            Handle<YieldTermStructure> yts =
                market->discountCurve(ccy.code(), cdoEngineBuilder->configuration(MarketContext::pricing));
 
            Date cdsStartDate = indexStartDateHint() == Date() ? schedule.dates().front() : indexStartDateHint();
            
            Schedule cdsSchedule(cdsStartDate, schedule.dates().back(),
                                 schedule.tenor(), schedule.calendar(), Following,
                                 schedule.terminationDateBusinessDayConvention(), schedule.rule(), false);
            indexCDS = QuantLib::ext::make_shared<QuantExt::IndexCreditDefaultSwap>(
                side, currTotalNtl, basketNotionals, 0.0, runningRate, cdsSchedule, bdc, dayCounter, settlesAccrual_,
                protectionPaymentTime_, Date(), Date(), QuantLib::ext::shared_ptr<Claim>(),
                lastPeriodDayCounter, rebatesAccrual_);
            Handle<DefaultProbabilityTermStructure> indexCreditCurve =
                indexCdsDefaultCurve(market, creditCurveIdWithTerm(), config)->curve();
            Handle<Quote> indexCdsRecovery = market->recoveryRate(creditCurveIdWithTerm(), config);
            auto indexPricingEngine =
                QuantLib::ext::make_shared<QuantExt::MidPointIndexCdsEngine>(indexCreditCurve, indexCdsRecovery->value(), yts);
            indexCDS->setPricingEngine(indexPricingEngine);
        } catch (const std::exception& e) {
            indexCDS = nullptr;
            WLOG("CDO constiuent calibration failed to build index cds.  Got "
                                                                     << e.what());
        }
        if (indexCDS) {
            cdsFairSpreads = indexCDS->fairSpreadClean();
            cdsNpvs = indexCDS->NPV();
        }
 
        auto it = engineFactory->engineData()->globalParameters().find("RunType");
        if (it != engineFactory->engineData()->globalParameters().end() && it->second != "PortfolioAnalyser") {
            
            Handle<YieldTermStructure> yts =
                market->discountCurve(ccy.code(), cdoEngineBuilder->configuration(MarketContext::pricing));
            
            std::vector<Handle<DefaultProbabilityTermStructure>> wrapperCurves;
            DLOG("Building wrapper curves for calibration");
            for (size_t i = 0; i < creditCurves.size(); ++i) {
                try {
                    const string& cc = creditCurves[i];
                    auto originalCurve = market->defaultCurve(cc, config)->curve();
                    wrapperCurves.push_back(
                        buildCalibratedConstiuentCurve(originalCurve, calibrationFactor));
                } catch (const std::exception& e) {
 
                    WLOG("CDO constiuent calibration failed during building wrapper curve for "
                         << creditCurves[i] << ", skip this curve. Got "
                                                                             << e.what());
                }
            }
 
            if (wrapperCurves.size() == dpts.size() && indexCDS) {
                LOG("Start bootstraping of the calibration factors");
                dpts.swap(wrapperCurves);
 
                auto cdsPricingEngineUnderlyingCurves =
                    QuantLib::ext::make_shared<QuantExt::MidPointIndexCdsEngine>(dpts, recoveryRates, yts);
 
                indexCDS->setPricingEngine(cdsPricingEngineUnderlyingCurves);
 
                try {
                    auto targetFunction = [&cdsNpvs, &calibrationFactor, &indexCDS](const double& factor) {
                        calibrationFactor->setValue(factor);
                        return cdsNpvs - indexCDS->NPV();
                    };
 
                    Brent solver;
                    double indexAdjustmentForUnderlyingCurves =
                        solver.solve(targetFunction, 1e-8, cdsFairSpreads / indexCDS->fairSpreadClean(), 0.001, 2);
 
                    DLOG("Calibration of indexterm " << io::iso_date(indexCDS->maturity())
                                                     << "successful, found solution "
                                                     << indexAdjustmentForUnderlyingCurves);
                    calibrationFactor->setValue(indexAdjustmentForUnderlyingCurves);
                } catch (const std::exception& e) {
                    WLOG("Calibration failed, at pillar " << io::iso_date(indexCDS->maturity())
                                                          << ", set calibration factor to 1 (uncalibrated), got "
                                                          << e.what());
                    calibrationFactor->setValue(1.0);
                }
 
                LOG("Calibration results for creditCurve:" << creditCurveIdWithTerm());
                LOG("Expiry \t CalibrationFactor \t NpvIntrinsic \t NpvIndexCurve \t NpvError \t "
                    "FairSpreadIntrinsic "
                    "\t FairSpreadIndexCurve \t FairSreadError");
 
                LOG(io::iso_date(indexCDS->maturity())
                    << "\t" << calibrationFactor->value() << "\t" << indexCDS->NPV() << "\t" << cdsNpvs << "\t"
                    << indexCDS->NPV() - cdsNpvs << "\t" << indexCDS->fairSpreadClean() << "\t" << cdsFairSpreads
                    << "\t" << indexCDS->fairSpreadClean() - cdsFairSpreads);
            }
        }
    }
 
    // Create the instruments.
    auto pool = QuantLib::ext::make_shared<Pool>();
    
    CreditPortfolioSensitivityDecomposition sensitivityDecomposition = cdoEngineBuilder->sensitivityDecomposition();
    useSensitivitySimplification_ = sensitivityDecomposition != CreditPortfolioSensitivityDecomposition::Underlying;
    Handle<DefaultProbabilityTermStructure> clientCurve;
    Handle<DefaultProbabilityTermStructure> baseCurve;
    vector<Time> baseCurveTimes;
    vector<Real> expLoss;
 
    if (cdoEngineBuilder->optimizedSensitivityCalculation()) {
        dpts = buildPerformanceOptimizedDefaultCurves(dpts);
    }
 
    for (Size i = 0; i < creditCurves.size(); ++i) {
        const string& cc = creditCurves[i];
        DefaultProbKey key = NorthAmericaCorpDefaultKey(ccy, SeniorSec, Period(), 1.0);
        Real recoveryRate = recoveryRates[i];
        auto defaultCurve = dpts[i];
        expLoss.push_back((1 - recoveryRate) * defaultCurve->defaultProbability(maturity_, true) * basketNotionals[i]);
        std::pair<DefaultProbKey, Handle<DefaultProbabilityTermStructure>> p(key, defaultCurve);
        vector<pair<DefaultProbKey, Handle<DefaultProbabilityTermStructure>>> probabilities(1, p);
        // Empty default set. Adjustments have been made above to account for existing credit events.
        Issuer issuer(probabilities, DefaultEventSet());
        pool->add(cc, issuer, key);
        DLOG("Issuer " << cc << " added to the pool.");
    }
 
    // If we use the simplification, we need a list of all credit curves and their weight to the basket
 
    if (sensitivityDecomposition == CreditPortfolioSensitivityDecomposition::LossWeighted) {
        basketConstituents_.clear();
        Real totalWeight = std::accumulate(expLoss.begin(), expLoss.end(), 0.0);
        for (Size basketIdx = 0; basketIdx < creditCurves.size(); basketIdx++) {
            string& creditCurve = creditCurves[basketIdx];
            Real weight = expLoss[basketIdx];
            if (basketConstituents_.count(creditCurve) == 0) {
                basketConstituents_[creditCurve] = weight / totalWeight;
            } else {
                basketConstituents_[creditCurve] += weight / totalWeight;
            }
        }
    } else if (sensitivityDecomposition == CreditPortfolioSensitivityDecomposition::NotionalWeighted) {
        basketConstituents_.clear();
        Real totalWeight = std::accumulate(basketNotionals.begin(), basketNotionals.end(), 0.0);
        for (Size basketIdx = 0; basketIdx < creditCurves.size(); basketIdx++) {
            string& creditCurve = creditCurves[basketIdx];
            Real weight = basketNotionals[basketIdx];
            if (basketConstituents_.count(creditCurve) == 0) {
                basketConstituents_[creditCurve] = weight / totalWeight;
            } else {
                basketConstituents_[creditCurve] += weight / totalWeight;
            }
        }
    } else if (sensitivityDecomposition == CreditPortfolioSensitivityDecomposition::DeltaWeighted) {
        basketConstituents_.clear();
        Real totalWeight = 0;
        for (Size basketIdx = 0; basketIdx < creditCurves.size(); basketIdx++) {
            string& creditCurve = creditCurves[basketIdx];
            Real notional = basketNotionals[basketIdx];
            auto defaultCurve = market->defaultCurve(creditCurve, config)->curve();
            Real constituentSurvivalProb = defaultCurve->survivalProbability(maturity_);
            Time t = defaultCurve->timeFromReference(maturity_);
            Real CR01 = t * constituentSurvivalProb * notional;
            if (basketConstituents_.find(creditCurve) == basketConstituents_.end())
                basketConstituents_.emplace(creditCurve, CR01);
            totalWeight += CR01;
        }
        // Normalize
        for (auto& decompWeight : basketConstituents_) {
            decompWeight.second /= totalWeight;
        }
    }
 
    // We will use a homogeneous pool loss model below if all notionals and recoveries are the same.
    bool homogeneous = all_of(basketNotionals.begin(), basketNotionals.end(),
                              [&basketNotionals](Real ntl) { return close_enough(ntl, basketNotionals[0]); });
    homogeneous = homogeneous && all_of(recoveryRates.begin(), recoveryRates.end(),
                                        [&recoveryRates](Real rr) { return close_enough(rr, recoveryRates[0]); });
 
    
    // vanilla holds the representation of the CDO, i.e. 1 * [0, Detach] instrument - 1 * [0, Attach] instrument,
    // without the upfront fee payment which is added below to create the full final instrument.
    QuantLib::ext::shared_ptr<Instrument> vanilla;
 
    // Tranche from 0 to detachment point.
    // If detachment point is 1.0, build an index CDS, i.e. [0, 100%] tranche. Otherwise an actual tranche.
    QuantLib::ext::shared_ptr<Instrument> cdoD;
    if (!close_enough(adjDetachPoint, 1.0)) {
        DLOG("Building detachment tranche [0," << adjDetachPoint << "].");
        // Set up the basket loss model.
        auto basket =
            QuantLib::ext::make_shared<QuantExt::Basket>(schedule[0], creditCurves, basketNotionals, pool, 0.0, adjDetachPoint);
        basket->setLossModel(
            cdoEngineBuilder->lossModel(qualifier(), recoveryRates, adjDetachPoint,
                                                         maturity_, homogeneous));
 
        auto cdoDetach =
            QuantLib::ext::make_shared<QuantExt::SyntheticCDO>(basket, side, schedule, 0.0, runningRate, dayCounter, bdc,
                                                       settlesAccrual_, protectionPaymentTime_, protectionStartDate, parseDate(upfrontDate_), boost::none, Null<Real>(), lastPeriodDayCounter);
 
        cdoDetach->setPricingEngine(
            cdoEngineBuilder->engine(ccy, false, {}, calibrationFactor, fixedRecovery));
        setSensitivityTemplate(*cdoEngineBuilder);
        cdoD = cdoDetach;
 
        DLOG("Detachment tranche [0," << adjDetachPoint << "] built.");
 
    } else {
        DLOG("Detachment point is 1.0 so building an index CDS for [0,1.0] 'tranche'.");
 
        /*auto cdsBuilder = QuantLib::ext::dynamic_pointer_cast<IndexCreditDefaultSwapEngineBuilder>(
            engineFactory->builder("IndexCreditDefaultSwap"));
        QL_REQUIRE(cdsBuilder, "Trade " << id() << " needs a IndexCreditDefaultSwapEngineBuilder.");
        */
        auto cds = QuantLib::ext::make_shared<QuantExt::IndexCreditDefaultSwap>(
            side, currTotalNtl, basketNotionals, 0.0, runningRate, schedule, bdc, dayCounter, settlesAccrual_,
            protectionPaymentTime_, protectionStartDate, Date(), QuantLib::ext::shared_ptr<Claim>(),
            lastPeriodDayCounter, rebatesAccrual_, protectionStartDate, 3);
 
        cds->setPricingEngine(
            cdoEngineBuilder->engine(ccy, true, creditCurves, calibrationFactor, fixedRecovery));
        setSensitivityTemplate(*cdoEngineBuilder);
        cdoD = cds;
 
        DLOG("Index CDS for [0,1.0] 'tranche' built.");
    }
 
    // Tranche from 0 to attachment point.
    // If attachment point is 0.0, the instrument is simply the 0 to detachment point CDO built above. If attachment
    // point is greater than 0, we build the 0 to attachment point tranche and the value of the CDO is the
    // difference between the detachment point CDO and attachment point CDO.
    if (close_enough(adjAttachPoint, 0.0)) {
        DLOG("Attachment point is 0 so the instrument is built.");
        vanilla = cdoD;
    } else {
        DLOG("Building attachment tranche [0," << adjAttachPoint << "].");
 
        // Set up the basket loss model.
        auto basket =
            QuantLib::ext::make_shared<QuantExt::Basket>(schedule[0], creditCurves, basketNotionals, pool, 0.0, adjAttachPoint);
        basket->setLossModel(cdoEngineBuilder->lossModel(qualifier(), recoveryRates, adjAttachPoint,
                                                         maturity_, homogeneous));
 
        auto cdoA =
            QuantLib::ext::make_shared<QuantExt::SyntheticCDO>(basket, side, schedule, 0.0, runningRate, dayCounter, bdc, settlesAccrual_, protectionPaymentTime_,
            protectionStartDate, parseDate(upfrontDate_), boost::none, fixedRecovery, lastPeriodDayCounter);
 
        cdoA->setPricingEngine(
            cdoEngineBuilder->engine(ccy, false, {}, calibrationFactor, fixedRecovery));
        setSensitivityTemplate(*cdoEngineBuilder);
 
        DLOG("Attachment tranche [0," << adjAttachPoint << "] built.");
 
        DLOG("Building attachment and detachment composite instrument.");
 
        auto composite = QuantLib::ext::make_shared<CompositeInstrument>();
        composite->add(cdoD);
        composite->subtract(cdoA);
        vanilla = composite;
 
        DLOG("Attachment and detachment composite instrument built.");
    }
 
    // Add the upfront fee payment here. Positive number indicates payment from buyer of protection to seller of
    // protection and a negative value indicates a payment from seller of protection to buyer of protection. The
    // upfront fee provided is interpreted as a fractional amount of the original tranche notional.
    if (upfrontDate != Date()) {
        vector<QuantLib::ext::shared_ptr<Instrument>> insts;
        vector<Real> mults;
        Real upfrontAmount = upfrontFee_ * origTrancheNtl;
        string configuration = cdoEngineBuilder->configuration(MarketContext::pricing);
        maturity_ =
            std::max(maturity_, addPremiums(insts, mults, 1.0, PremiumData(upfrontAmount, ccy.code(), upfrontDate),
                                            side == Protection::Buyer ? -1.0 : 1.0, ccy, engineFactory, configuration));
 
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(vanilla, 1.0, insts, mults);
 
    } else {
        // If no upfront payment, the instrument is simply the vanilla instrument.
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(vanilla);
    }
 
    additionalData_["originalNotional"] = origTrancheNtl;
    additionalData_["currentNotional"] = currTrancheNtl;
 
    DLOG("CDO instrument built");
}

Here is the call graph for this function:

◆ qualifier()

const string & qualifier ( ) const

Inspectors.

Definition at line 64 of file cdo.hpp.

64{ return qualifier_; }

◆ leg()

const LegData & leg ( ) const

Definition at line 65 of file cdo.hpp.

65{ return legData_; }

◆ basketData()

const BasketData & basketData ( ) const

Definition at line 66 of file cdo.hpp.

66{ return basketData_; }

◆ attachmentPoint()

const double & attachmentPoint ( ) const

Definition at line 67 of file cdo.hpp.

67{ return attachmentPoint_; }

◆ detachmentPoint()

const double & detachmentPoint ( ) const

Definition at line 68 of file cdo.hpp.

68{ return detachmentPoint_; }

◆ protectionPaymentTime()

QuantExt::CreditDefaultSwap::ProtectionPaymentTime protectionPaymentTime ( ) const

Definition at line 69 of file cdo.hpp.

69{ return protectionPaymentTime_; }

Here is the caller graph for this function:

◆ protectionStart()

const string & protectionStart ( ) const

Definition at line 70 of file cdo.hpp.

70{ return protectionStart_; }

Here is the caller graph for this function:

◆ upfrontDate()

const string & upfrontDate ( ) const

Definition at line 71 of file cdo.hpp.

71{ return upfrontDate_; }

Here is the caller graph for this function:

◆ upfrontFee()

const double & upfrontFee ( ) const

Definition at line 72 of file cdo.hpp.

72{ return upfrontFee_; }

Here is the caller graph for this function:

◆ settlesAccrual()

bool settlesAccrual ( ) const

Definition at line 73 of file cdo.hpp.

73{ return settlesAccrual_; }

Here is the caller graph for this function:

◆ rebatesAccrual()

bool rebatesAccrual ( ) const

Definition at line 74 of file cdo.hpp.

74{ return rebatesAccrual_; }

Here is the caller graph for this function:

◆ recoveryRate()

const Real & recoveryRate ( ) const

Definition at line 75 of file cdo.hpp.

75{ return recoveryRate_; }

◆ useSensitivitySimplification()

bool useSensitivitySimplification ( ) const

Definition at line 76 of file cdo.hpp.

76{ return useSensitivitySimplification_; }

◆ basketConstituents()

const std::map< std::string, Real > & basketConstituents ( ) const

Definition at line 77 of file cdo.hpp.

77{ return basketConstituents_; }

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 655 of file cdo.cpp.

                                        {
    Trade::fromXML(node);
    XMLNode* cdoNode = XMLUtils::getChildNode(node, "CdoData");
    QL_REQUIRE(cdoNode, "No CdoData Node");
    qualifier_ = XMLUtils::getChildValue(cdoNode, "Qualifier", true);
    protectionStart_ = XMLUtils::getChildValue(cdoNode, "ProtectionStart", true);
    upfrontDate_ = XMLUtils::getChildValue(cdoNode, "UpfrontDate", false);
 
    // zero if empty or missing
    upfrontFee_ = Null<Real>();
    string strUpfrontFee = XMLUtils::getChildValue(cdoNode, "UpfrontFee", false);
    if (!strUpfrontFee.empty()) {
        upfrontFee_ = parseReal(strUpfrontFee);
    }
    settlesAccrual_ = XMLUtils::getChildValueAsBool(cdoNode, "SettlesAccrual", false);      // default = Y
    rebatesAccrual_ = XMLUtils::getChildValueAsBool(cdoNode, "RebatesAccrual", false);      // default = Y
    protectionPaymentTime_ = QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault; // set default
 
    // Recovery rate is Null<Real>() on a standard CDO i.e. if "FixedRecoveryRate" field is not populated.
    recoveryRate_ = Null<Real>();
    string strRecoveryRate = XMLUtils::getChildValue(node, "FixedRecoveryRate", false);
    if (!strRecoveryRate.empty()) {
        recoveryRate_ = parseReal(strRecoveryRate);
    }
 
    // for backwards compatibility only
    if (auto c = XMLUtils::getChildNode(cdoNode, "PaysAtDefaultTime"))
        if (!parseBool(XMLUtils::getNodeValue(c)))
            protectionPaymentTime_ = QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atPeriodEnd;
    // new node overrides deprecated one, if both should be given
    if (auto c = XMLUtils::getChildNode(cdoNode, "ProtectionPaymentTime")) {
        if (XMLUtils::getNodeValue(c) == "atDefault")
            protectionPaymentTime_ = QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault;
        else if (XMLUtils::getNodeValue(c) == "atPeriodEnd")
            protectionPaymentTime_ = QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atPeriodEnd;
        else if (XMLUtils::getNodeValue(c) == "atMaturity")
            protectionPaymentTime_ = QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atMaturity;
        else {
            QL_FAIL("protection payment time '" << XMLUtils::getNodeValue(c)
                                                << "' not known, expected atDefault, atPeriodEnd, atMaturity");
        }
    }
    attachmentPoint_ = XMLUtils::getChildValueAsDouble(cdoNode, "AttachmentPoint", true);
    detachmentPoint_ = XMLUtils::getChildValueAsDouble(cdoNode, "DetachmentPoint", true);
    XMLNode* legNode = XMLUtils::getChildNode(cdoNode, "LegData");
    legData_.fromXML(legNode);
    XMLNode* basketNode = XMLUtils::getChildNode(cdoNode, "BasketData");
    if (basketNode)
        basketData_.fromXML(basketNode);
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 706 of file cdo.cpp.

                                                   {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* cdoNode = doc.allocNode("CdoData");
    XMLUtils::appendNode(node, cdoNode);
    XMLUtils::addChild(doc, cdoNode, "Qualifier", qualifier_);
    XMLUtils::addChild(doc, cdoNode, "ProtectionStart", protectionStart_);
    if (!upfrontDate_.empty()) {
        XMLUtils::addChild(doc, cdoNode, "UpfrontDate", upfrontDate_);
    }
    if (upfrontFee_ != Null<Real>()) {
        XMLUtils::addChild(doc, cdoNode, "UpfrontFee", upfrontFee_);
    }
    XMLUtils::addChild(doc, cdoNode, "SettlesAccrual", settlesAccrual_);
    if (!rebatesAccrual_)
        XMLUtils::addChild(doc, node, "RebatesAccrual", rebatesAccrual_);
    if (protectionPaymentTime_ == QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atDefault)
        XMLUtils::addChild(doc, cdoNode, "ProtectionPaymentTime", "atDefault");
    else if (protectionPaymentTime_ == QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atPeriodEnd)
        XMLUtils::addChild(doc, cdoNode, "ProtectionPaymentTime", "atPeriodEnd");
    else if (protectionPaymentTime_ == QuantExt::CreditDefaultSwap::ProtectionPaymentTime::atMaturity)
        XMLUtils::addChild(doc, cdoNode, "ProtectionPaymentTime", "atMaturity");
    else {
        QL_FAIL("CreditDefaultSwapData::toXML(): unexpected protectionPaymentTime_");
    }
    if (recoveryRate_ != Null<Real>())
        XMLUtils::addChild(doc, node, "FixedRecoveryRate", recoveryRate_);
    XMLUtils::addChild(doc, cdoNode, "AttachmentPoint", attachmentPoint_);
    XMLUtils::addChild(doc, cdoNode, "DetachmentPoint", detachmentPoint_);
    XMLUtils::appendNode(cdoNode, legData_.toXML(doc));
    XMLUtils::appendNode(cdoNode, basketData_.toXML(doc));
    return node;
}

Here is the call graph for this function:

◆ extractTimeGridDefaultCurve()

vector< Time > extractTimeGridDefaultCurve ( const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > & dpts )

static

Definition at line 739 of file cdo.cpp.

                                                                                                             {
    if (auto c = QuantLib::ext::dynamic_pointer_cast<SpreadedSurvivalProbabilityTermStructure>(*dpts)) {
        return SyntheticCDO::extractTimeGridDefaultCurve(c->referenceCurve());
    } else if (auto c = QuantLib::ext::dynamic_pointer_cast<InterpolatedSurvivalProbabilityCurve<LogLinear>>(*dpts)) {
        return c->times();
    } else if (auto c = QuantLib::ext::dynamic_pointer_cast<InterpolatedHazardRateCurve<BackwardFlat>>(*dpts)) {
        return c->times();
    } else if (auto c = QuantLib::ext::dynamic_pointer_cast<SurvivalProbabilityCurve<LogLinear>>(*dpts)) {
        return c->times();
    } else {
        WLOG("Extraction of time points failed, unsupported default probability termstructure");
        return vector<double>();
    }
}

Here is the caller graph for this function:

◆ buildCalibratedConstiuentCurve()

QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > buildCalibratedConstiuentCurve	(	const QuantLib::Handle< QuantLib::DefaultProbabilityTermStructure > &	curve,
		const QuantLib::ext::shared_ptr< SimpleQuote > &	calibrationFactor
	)

static

Definition at line 755 of file cdo.cpp.

                                                                                                          {
    if (!calibrationFactor) {
        return curve;
    }
    auto curveTimes = extractTimeGridDefaultCurve(curve);
    vector<Handle<Quote>> spreads;
    for (size_t timeIdx = 0; timeIdx < curveTimes.size(); ++timeIdx) {
        auto sp = curve->survivalProbability(curveTimes[timeIdx]);
         auto compQuote = QuantLib::ext::make_shared<CompositeQuote<std::function<double(double, double)>>>(
            Handle<Quote>(calibrationFactor),
            Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(sp)),
            [](const double q1, const double q2) -> double { return std::exp(-(1 - q1) * std::log(q2)); });
        spreads.push_back(Handle<Quote>(compQuote));
    }
    Handle<DefaultProbabilityTermStructure> targetCurve = Handle<DefaultProbabilityTermStructure>(
        QuantLib::ext::make_shared<SpreadedSurvivalProbabilityTermStructure>(curve, curveTimes, spreads));
    if (curve->allowsExtrapolation()) {
        targetCurve->enableExtrapolation();
    }
    return targetCurve;   
}

Here is the caller graph for this function:

◆ creditCurveIdWithTerm()

std::string creditCurveIdWithTerm ( ) const

Get credit curve id with term suffix "_5Y". If the creditCurveId contains such a suffix already this is used. Otherwise we try to imply it from the schedule. If that is not possible, the creditCurveId without tenor is returned.

Definition at line 778 of file cdo.cpp.

                                                    {
    auto p = ore::data::splitCurveIdWithTenor(qualifier());
    if (p.second != 0 * Days || !isIndexTranche())
        return qualifier();
 
    QuantLib::Schedule s = makeSchedule(leg().schedule());
    if (s.dates().empty())
        return p.first;
    QuantLib::Period t = QuantExt::implyIndexTerm(
        indexStartDateHint_ == Date() ? s.dates().front() : indexStartDateHint_, s.dates().back());
    if (t != 0 * Days)
        return p.first + "_" + ore::data::to_string(t);
    return p.first;
}

Here is the call graph for this function:

◆ setIndexStartDateHint()

void setIndexStartDateHint ( const QuantLib::Date & d ) const

If set this is used to derive the term instead of the schedule start date. A concession to bad trade setups really, where the start date is not set to the index effective date

Definition at line 96 of file cdo.hpp.

96{ indexStartDateHint_ = d; }

ore::data::SyntheticCDO::indexStartDateHint_

QuantLib::Date indexStartDateHint_

Definition: cdo.hpp:122

◆ indexStartDateHint()

const QuantLib::Date & indexStartDateHint ( ) const

Get the index start date hint, or null if it was never set

Definition at line 99 of file cdo.hpp.

99{ return indexStartDateHint_; }

◆ isIndexTranche()

bool isIndexTranche ( ) const

private

Definition at line 103 of file cdo.hpp.

103{ return qualifier_.size() == 13 && qualifier_.substr(0, 3) == "RED"; }

Member Data Documentation

◆ qualifier_

string qualifier_

private

Definition at line 105 of file cdo.hpp.

◆ legData_

LegData legData_

private

Definition at line 106 of file cdo.hpp.

◆ basketData_

BasketData basketData_

private

Definition at line 107 of file cdo.hpp.

◆ attachmentPoint_

double attachmentPoint_

private

Definition at line 108 of file cdo.hpp.

◆ detachmentPoint_

double detachmentPoint_

private

Definition at line 109 of file cdo.hpp.

◆ settlesAccrual_

bool settlesAccrual_

private

Definition at line 110 of file cdo.hpp.

◆ protectionPaymentTime_

QuantExt::CreditDefaultSwap::ProtectionPaymentTime protectionPaymentTime_

private

Definition at line 111 of file cdo.hpp.

◆ protectionStart_

string protectionStart_

private

Definition at line 112 of file cdo.hpp.

◆ upfrontDate_

string upfrontDate_

private

Definition at line 113 of file cdo.hpp.

◆ upfrontFee_

double upfrontFee_

private

Definition at line 114 of file cdo.hpp.

◆ rebatesAccrual_

bool rebatesAccrual_

private

Definition at line 115 of file cdo.hpp.

◆ recoveryRate_

Real recoveryRate_

private

Definition at line 116 of file cdo.hpp.

◆ basketConstituents_

std::map<std::string, double> basketConstituents_

private

Definition at line 120 of file cdo.hpp.

◆ useSensitivitySimplification_

bool useSensitivitySimplification_

private

Definition at line 121 of file cdo.hpp.

◆ indexStartDateHint_

QuantLib::Date indexStartDateHint_

mutableprivate

Definition at line 122 of file cdo.hpp.

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SyntheticCDO() [1/2]

◆ SyntheticCDO() [2/2]

Member Function Documentation

◆ build()

◆ qualifier()

◆ leg()

◆ basketData()

◆ attachmentPoint()

◆ detachmentPoint()

◆ protectionPaymentTime()

◆ protectionStart()

◆ upfrontDate()

◆ upfrontFee()

◆ settlesAccrual()

◆ rebatesAccrual()

◆ recoveryRate()

◆ useSensitivitySimplification()

◆ basketConstituents()

◆ fromXML()

◆ toXML()

◆ extractTimeGridDefaultCurve()

◆ buildCalibratedConstiuentCurve()

◆ creditCurveIdWithTerm()

◆ setIndexStartDateHint()

◆ indexStartDateHint()

◆ isIndexTranche()

Member Data Documentation

◆ qualifier_

◆ legData_

◆ basketData_

◆ attachmentPoint_

◆ detachmentPoint_

◆ settlesAccrual_

◆ protectionPaymentTime_

◆ protectionStart_

◆ upfrontDate_

◆ upfrontFee_

◆ rebatesAccrual_

◆ recoveryRate_

◆ basketConstituents_

◆ useSensitivitySimplification_

◆ indexStartDateHint_