#include <ored/portfolio/creditdefaultswapoption.hpp>

Inheritance diagram for CreditDefaultSwapOption:

Collaboration diagram for CreditDefaultSwapOption:

Classes
class	AuctionSettlementInformation

Public Member Functions
	CreditDefaultSwapOption ()
	Default constructor. More...

	CreditDefaultSwapOption (const Envelope &env, const OptionData &option, const CreditDefaultSwapData &swap, QuantLib::Real strike=QuantLib::Null< QuantLib::Real >(), const std::string &strikeType="Spread", bool knockOut=true, const std::string &term="", const boost::optional< AuctionSettlementInformation > &asi=boost::none)
	Constructor. More...

Trade interface
void	build (const QuantLib::ext::shared_ptr< EngineFactory > &ef) override

Inspectors
const OptionData &	option () const

const CreditDefaultSwapData &	swap () const

QuantLib::Real	strike () const

const std::string &	strikeType () const

bool	knockOut () const

const std::string &	term () const

const boost::optional< AuctionSettlementInformation > &	auctionSettlementInformation () 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...

Serialisation
OptionData	option_

CreditDefaultSwapData	swap_

QuantLib::Real	strike_

std::string	strikeType_

bool	knockOut_

std::string	term_

boost::optional< AuctionSettlementInformation >	asi_

void	fromXML (XMLNode *node) override

XMLNode *	toXML (XMLDocument &doc) const override

void	buildNoDefault (const QuantLib::ext::shared_ptr< EngineFactory > &ef)
	Build CDS option given that no default. More...

void	buildDefaulted (const QuantLib::ext::shared_ptr< EngineFactory > &ef)
	Build instrument given that default has occurred. More...

Date	addPremium (const QuantLib::ext::shared_ptr< EngineFactory > &ef, const QuantLib::Currency &tradeCurrency, const std::string &marketConfig, std::vector< QuantLib::ext::shared_ptr< QuantLib::Instrument > > &additionalInstruments, std::vector< QuantLib::Real > &additionalMultipliers)
	Add the premium payment. More...

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

Definition at line 36 of file creditdefaultswapoption.hpp.

Constructor & Destructor Documentation

◆ CreditDefaultSwapOption() [1/2]

CreditDefaultSwapOption ( )

Default constructor.

Definition at line 62 of file creditdefaultswapoption.cpp.

63 : Trade("CreditDefaultSwapOption"), strike_(Null<Real>()), knockOut_(true) {}

ore::data::CreditDefaultSwapOption::knockOut_

bool knockOut_

Definition: creditdefaultswapoption.hpp:112

ore::data::CreditDefaultSwapOption::strike_

QuantLib::Real strike_

Definition: creditdefaultswapoption.hpp:110

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

◆ CreditDefaultSwapOption() [2/2]

CreditDefaultSwapOption	(	const Envelope &	env,
		const OptionData &	option,
		const CreditDefaultSwapData &	swap,
		QuantLib::Real	strike = `QuantLib::Null< QuantLib::Real >()`,
		const std::string &	strikeType = `"Spread"`,
		bool	knockOut = `true`,
		const std::string &	term = `""`,
		const boost::optional< AuctionSettlementInformation > &	asi = `boost::none`
	)

Constructor.

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 76 of file creditdefaultswapoption.cpp.

                                                                                             {
 
    DLOG("CreditDefaultSwapOption::build() called for trade " << id());
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = string("Credit");
    additionalData_["isdaBaseProduct"] = string("Swaptions");
    // set isdaSubProduct to entityType in credit reference data
    additionalData_["isdaSubProduct"] = string("");
    string entity =
        swap_.referenceInformation() ? swap_.referenceInformation()->referenceEntityId() : swap_.creditCurveId();
    QuantLib::ext::shared_ptr<ReferenceDataManager> refData = engineFactory->referenceData();
    if (refData && refData->hasData("Credit", entity)) {
        auto refDatum = refData->getData("Credit", entity);
        QuantLib::ext::shared_ptr<CreditReferenceDatum> creditRefDatum =
            QuantLib::ext::dynamic_pointer_cast<CreditReferenceDatum>(refDatum);
        additionalData_["isdaSubProduct"] = creditRefDatum->creditData().entityType;
        if (creditRefDatum->creditData().entityType == "") {
            ALOG("EntityType is blank in credit reference data for entity " << entity);
        }
    } else {
        ALOG("Credit reference data missing for entity " << entity << ", isdaSubProduct left blank");
    }
    // Skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = string("");
 
    // Notionals
    const auto& legData = swap_.leg();
    const auto& ntls = legData.notionals();
    QL_REQUIRE(ntls.size() == 1, "CreditDefaultSwapOption requires a single notional.");
    notional_ = ntls.front();
    notionalCurrency_ = legData.currency();
 
    // Type of instrument we build depends on whether the reference entity has already defaulted.
    if (asi_) {
        buildDefaulted(engineFactory);
    } else {
        buildNoDefault(engineFactory);
    }
}

Here is the call graph for this function:

◆ option()

const OptionData & option ( ) const

Definition at line 117 of file creditdefaultswapoption.cpp.

                                                        {
    return option_;
}

◆ swap()

const CreditDefaultSwapData & swap ( ) const

Definition at line 121 of file creditdefaultswapoption.cpp.

                                                                 {
    return swap_;
}

◆ strike()

Real strike ( ) const

Definition at line 125 of file creditdefaultswapoption.cpp.

                                           {
    return strike_;
}

Here is the caller graph for this function:

◆ strikeType()

const string & strikeType ( ) const

Definition at line 129 of file creditdefaultswapoption.cpp.

                                                        {
    return strikeType_;
}

Here is the caller graph for this function:

◆ knockOut()

bool knockOut ( ) const

Definition at line 133 of file creditdefaultswapoption.cpp.

                                             {
    return knockOut_;
}

◆ term()

const string & term ( ) const

Definition at line 137 of file creditdefaultswapoption.cpp.

                                                  {
    return term_;
}

◆ auctionSettlementInformation()

const boost::optional< ASI > & auctionSettlementInformation ( ) const

Definition at line 142 of file creditdefaultswapoption.cpp.

                                                                                      {
    return asi_;
}

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 146 of file creditdefaultswapoption.cpp.

                                                   {
 
    Trade::fromXML(node);
 
    XMLNode* cdsOptionData = XMLUtils::getChildNode(node, "CreditDefaultSwapOptionData");
    QL_REQUIRE(cdsOptionData, "Expected CreditDefaultSwapOptionData node on trade " << id() << ".");
    strike_ = XMLUtils::getChildValueAsDouble(cdsOptionData, "Strike", false, Null<Real>());
    strikeType_ = "Spread";
    if (auto n = XMLUtils::getChildNode(cdsOptionData, "StrikeType")) {
        strikeType_ = XMLUtils::getNodeValue(n);
    }
    knockOut_ = XMLUtils::getChildValueAsBool(cdsOptionData, "KnockOut", false, true);
    term_ = XMLUtils::getChildValue(cdsOptionData, "Term", false);
 
    if (XMLNode* asiNode = XMLUtils::getChildNode(cdsOptionData, "AuctionSettlementInformation"))
        asi_->fromXML(asiNode);
 
    XMLNode* cdsData = XMLUtils::getChildNode(cdsOptionData, "CreditDefaultSwapData");
    QL_REQUIRE(cdsData, "Expected CreditDefaultSwapData node on trade " << id() << ".");
    swap_.fromXML(cdsData);
 
    XMLNode* optionData = XMLUtils::getChildNode(cdsOptionData, "OptionData");
    QL_REQUIRE(optionData, "Expected OptionData node on trade " << id() << ".");
    option_.fromXML(optionData);
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 172 of file creditdefaultswapoption.cpp.

                                                              {
 
    // Trade node
    XMLNode* node = Trade::toXML(doc);
 
    // CreditDefaultSwapOptionData node
    XMLNode* cdsOptionDataNode = doc.allocNode("CreditDefaultSwapOptionData");
    if (strike_ != Null<Real>())
        XMLUtils::addChild(doc, cdsOptionDataNode, "Strike", strike_);
    if (strikeType_ != "")
        XMLUtils::addChild(doc, cdsOptionDataNode, "StrikeType", strikeType_);
    XMLUtils::addChild(doc, cdsOptionDataNode, "KnockOut", knockOut_);
    if (!term_.empty())
        XMLUtils::addChild(doc, cdsOptionDataNode, "Term", term_);
 
    if (asi_)
        XMLUtils::appendNode(cdsOptionDataNode, asi_->toXML(doc));
 
    XMLUtils::appendNode(cdsOptionDataNode, swap_.toXML(doc));
    XMLUtils::appendNode(cdsOptionDataNode, option_.toXML(doc));
 
    // Add CreditDefaultSwapOptionData node to Trade node
    XMLUtils::appendNode(node, cdsOptionDataNode);
 
    return node;
}

Here is the call graph for this function:

◆ buildNoDefault()

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

private

Build CDS option given that no default.

Definition at line 199 of file creditdefaultswapoption.cpp.

                                                                                                      {
 
    DLOG("CreditDefaultSwapOption: building CDS option trade " << id() << " given no default.");
 
    // Need fixed leg data with one rate. This should be the standard running coupon on the CDS e.g. 
    // generally 100bp for IG CDS and 500bp for HY CDS. For single name CDS options, one can use this field to give 
    // the strike spread. It may matter for the resulting valuation depending on the engine that is used - see 
    // "A CDS Option Miscellany, Richard J. Martin, 2019, Section 2.4".
    const auto& legData = swap_.leg();
    QL_REQUIRE(legData.legType() == "Fixed", "CDS option " << id() << " requires fixed leg.");
    auto fixedLegData = QuantLib::ext::dynamic_pointer_cast<FixedLegData>(legData.concreteLegData());
    QL_REQUIRE(fixedLegData->rates().size() == 1, "Index CDS option " << id() << " requires single fixed rate.");
    auto runningCoupon = fixedLegData->rates().front();
 
    // Payer (Receiver) swaption if the leg is paying (receiving).
    auto side = legData.isPayer() ? Protection::Side::Buyer : Protection::Side::Seller;
 
    // Day counter. In general for CDS, the standard day counter is Actual/360 and the final
    // period coupon accrual includes the maturity date.
    Actual360 standardDayCounter;
    const std::string& strDc = legData.dayCounter();
    DayCounter dc = strDc.empty() ? standardDayCounter : parseDayCounter(strDc);
    DayCounter lastPeriodDayCounter = dc == standardDayCounter ? Actual360(true) : dc;
 
    // Schedule
    Schedule schedule = makeSchedule(legData.schedule());
    BusinessDayConvention payConvention = legData.paymentConvention().empty() ? Following :
        parseBusinessDayConvention(legData.paymentConvention());
 
    // Don't support upfront fee on the underlying CDS for the moment.
    QL_REQUIRE(swap_.upfrontFee() == Null<Real>() || close(swap_.upfrontFee(), 0.0),
        "Upfront fee on the CDS underlying a CDS option is not supported.");
 
    // The underlying CDS trade
    auto cds = QuantLib::ext::make_shared<QuantLib::CreditDefaultSwap>(side, notional_, runningCoupon, schedule,
        payConvention, dc, swap_.settlesAccrual(), swap_.protectionPaymentTime(), swap_.protectionStart(),
        QuantLib::ext::shared_ptr<Claim>(), lastPeriodDayCounter, true, swap_.tradeDate(), swap_.cashSettlementDays());
 
    // Copying here what is done for the index CDS option. The comment there is:
    // Align option product maturities with ISDA AANA/GRID guidance as of November 2020.
    maturity_ = std::max(cds->coupons().back()->date(), option_.premiumData().latestPremiumDate());
 
    // Set engine on the underlying CDS.
    auto cdsBuilder = QuantLib::ext::dynamic_pointer_cast<CreditDefaultSwapEngineBuilder>(
        engineFactory->builder("CreditDefaultSwap"));
    QL_REQUIRE(cdsBuilder, "CreditDefaultSwapOption expected CDS engine " <<
        " builder for underlying while building trade " << id() << ".");
    npvCurrency_ = legData.currency();
    auto ccy = parseCurrency(npvCurrency_);
    cds->setPricingEngine(cdsBuilder->engine(ccy, swap_.creditCurveId(), swap_.recoveryRate()));
    setSensitivityTemplate(*cdsBuilder);
 
    // Check option data
    QL_REQUIRE(option_.style() == "European", "CreditDefaultSwapOption option style must" <<
        " be European but got " << option_.style() << ".");
    QL_REQUIRE(!option_.payoffAtExpiry(), "CreditDefaultSwapOption payoff must be at exercise.");
    QL_REQUIRE(option_.exerciseFees().empty(), "CreditDefaultSwapOption cannot handle exercise fees.");
 
    // Exercise must be European
    const auto& exerciseDates = option_.exerciseDates();
    QL_REQUIRE(exerciseDates.size() == 1, "CreditDefaultSwapOption expects one exercise date" <<
        " but got " << exerciseDates.size() << " exercise dates.");
    Date exerciseDate = parseDate(exerciseDates.front());
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
 
    // Limit strike type to Spread for now.
    auto strikeType = parseCdsOptionStrikeType(strikeType_);
    QL_REQUIRE(strikeType == QuantExt::CdsOption::Spread, "CreditDefaultSwapOption strike type must be Spread.");
 
    // If the strike_ is Null, the strike is taken as the running coupon.
    Real strike = strike_ == Null<Real>() ? runningCoupon : strike_;
 
    // Build the option instrument
    auto cdsOption = QuantLib::ext::make_shared<QuantExt::CdsOption>(cds, exercise, knockOut_, strike, strikeType);
 
    // Set the option engine
    auto cdsOptionEngineBuilder = QuantLib::ext::dynamic_pointer_cast<CreditDefaultSwapOptionEngineBuilder>(
        engineFactory->builder("CreditDefaultSwapOption"));
    QL_REQUIRE(cdsOptionEngineBuilder, "CreditDefaultSwapOption expected CDS option engine " <<
        " builder for underlying while building trade " << id() << ".");
    cdsOption->setPricingEngine(cdsOptionEngineBuilder->engine(ccy, swap_.creditCurveId(), term_));
    setSensitivityTemplate(*cdsOptionEngineBuilder);
 
    // Set Trade members.
    legs_ = { cds->coupons() };
    legCurrencies_ = { npvCurrency_ };
    legPayers_ = { legData.isPayer() };
 
    // Include premium if enough information is provided
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
    string marketConfig = cdsOptionEngineBuilder->configuration(MarketContext::pricing);
    addPremium(engineFactory, ccy, marketConfig, additionalInstruments, additionalMultipliers);
 
    // Instrument wrapper depends on the settlement type.
    Position::Type positionType = parsePositionType(option_.longShort());
    Settlement::Type settleType = parseSettlementType(option_.settlement());
    // The instrument build should be indpednent of the evaluation date. However, the general behavior
    // in ORE (e.g. IR swaptions) for normal pricing runs is that the option is considered expired on
    // the expiry date with no assumptions on an (automatic) exercise. Therefore we build a vanilla
    // instrument if the exercise date is <= the eval date at build time.
    if (settleType == Settlement::Cash || exerciseDate <= Settings::instance().evaluationDate()) {
        Real indicatorLongShort = positionType == Position::Long ? 1.0 : -1.0;
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(cdsOption, indicatorLongShort,
            additionalInstruments, additionalMultipliers);
    } else {
        bool isLong = positionType == Position::Long;
        bool isPhysical = settleType == Settlement::Physical;
        instrument_ = QuantLib::ext::make_shared<EuropeanOptionWrapper>(cdsOption, isLong, exerciseDate,
            isPhysical, cds, 1.0, 1.0, additionalInstruments, additionalMultipliers);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildDefaulted()

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

private

Build instrument given that default has occurred.

Definition at line 312 of file creditdefaultswapoption.cpp.

                                                                                                      {
 
    DLOG("CreditDefaultSwapOption: building CDS option trade " << id() << " given default occurred.");
 
    // We add a simple payment for CDS options where the reference entity has already defaulted.
    // If it is a knock-out CDS option, we add a dummy payment of 0.0 with date today instead of throwing.
    const auto& legData = swap_.leg();
    Date paymentDate = engineFactory->market()->asofDate();
    Real amount = 0.0;
    if (!knockOut_) {
        paymentDate = asi_->auctionSettlementDate();
        amount = notional_ * (1 - asi_->auctionFinalPrice());
        // If it is a receiver option, i.e. selling protection, the FEP is paid out.
        if (!legData.isPayer())
            amount *= -1.0;
    }
 
    Position::Type positionType = parsePositionType(option_.longShort());
    Real indicatorLongShort = positionType == Position::Long ? 1.0 : -1.0;
 
    // Use the add premiums method to add the payment.
    string marketConfig = Market::defaultConfiguration;
    auto ccy = parseCurrency(notionalCurrency_);
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
    Date premiumPayDate =
        addPremiums(additionalInstruments, additionalMultipliers, indicatorLongShort,
                    PremiumData(amount, notionalCurrency_, paymentDate), 1.0, ccy, engineFactory, marketConfig);
    DLOG("FEP payment (date = " << paymentDate << ", amount = " << amount << ") added for CDS option " << id() << ".");
 
    // Use the instrument added as the main instrument and clear the vectors
    auto qlInst = additionalInstruments.back();
    QL_REQUIRE(qlInst, "Expected a FEP payment to have been added for CDS option " << id() << ".");
    maturity_ = std::max(paymentDate, premiumPayDate);
    additionalInstruments.clear();
    additionalMultipliers.clear();
 
    // Include premium if enough information is provided
    addPremium(engineFactory, ccy, marketConfig, additionalInstruments, additionalMultipliers);
 
    // Instrument wrapper.
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(qlInst, indicatorLongShort,
        additionalInstruments, additionalMultipliers);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addPremium()

Date addPremium	(	const QuantLib::ext::shared_ptr< EngineFactory > &	ef,
		const QuantLib::Currency &	tradeCurrency,
		const std::string &	marketConfig,
		std::vector< QuantLib::ext::shared_ptr< QuantLib::Instrument > > &	additionalInstruments,
		std::vector< QuantLib::Real > &	additionalMultipliers
	)

private

Add the premium payment.

Definition at line 357 of file creditdefaultswapoption.cpp.

                                         {
        // The premium amount is always provided as a non-negative amount. Assign the correct sign here i.e.
        // pay the premium if long the option and receive the premium if short the option.
        Position::Type positionType = parsePositionType(option_.longShort());
        Real indicatorLongShort = positionType == Position::Long ? 1.0 : -1.0;
        return addPremiums(additionalInstruments, additionalMultipliers, indicatorLongShort, option_.premiumData(),
                           indicatorLongShort, tradeCurrency, ef, marketConfig);
}