#include <ored/portfolio/indexcreditdefaultswapoption.hpp>

Inheritance diagram for IndexCreditDefaultSwapOption:

Collaboration diagram for IndexCreditDefaultSwapOption:

Classes
struct	Notionals
	Hold related notionals that are known on valuation date. More...

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

	IndexCreditDefaultSwapOption (const ore::data::Envelope &env, const IndexCreditDefaultSwapData &swap, const ore::data::OptionData &option, QuantLib::Real strike, const std::string &indexTerm="", const std::string &strikeType="Spread", const QuantLib::Date &tradeDate=Date(), const QuantLib::Date &fepStartDate=Date())
	Detailed constructor. More...

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

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

Serialisation
void	fromXML (ore::data::XMLNode *node) override

ore::data::XMLNode *	toXML (ore::data::XMLDocument &doc) const override

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 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...

Inspectors
IndexCreditDefaultSwapData	swap_

ore::data::OptionData	option_

QuantLib::Real	strike_

std::string	indexTerm_

std::string	strikeType_

QuantLib::Date	tradeDate_

QuantLib::Date	fepStartDate_

CreditPortfolioSensitivityDecomposition	sensitivityDecomposition_

QuantLib::Real	effectiveStrike_

std::string	effectiveStrikeType_

QuantLib::Period	effectiveIndexTerm_

std::string	volCurveId_

Notionals	notionals_
	Populated during trade building. More...

map< string, Real >	constituents_
	map of all the constituents to notionals More...

const IndexCreditDefaultSwapData &	swap () const

const ore::data::OptionData &	option () const

const std::string &	indexTerm () const

QuantLib::Real	strike () const

QuantLib::Option::Type	callPut () const

const std::string &	strikeType () const

const QuantLib::Date &	tradeDate () const

const QuantLib::Date &	fepStartDate () const

const CreditPortfolioSensitivityDecomposition	sensitivityDecomposition () const

QuantLib::Real	effectiveStrike () const

const std::string &	effectiveStrikeType () const

const QuantLib::Period &	effectiveIndexTerm () const

std::string	creditCurveId () const

const std::string &	volCurveId () const

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

void	fromBasket (const QuantLib::Date &asof, std::map< std::string, QuantLib::Real > &constituents)
	Populate constituent notionals and curve IDs from basket data. More...

void	fromReferenceData (const QuantLib::Date &asof, std::map< std::string, QuantLib::Real > &constituents, const QuantLib::ext::shared_ptr< ReferenceDataManager > &refData)
	Populate constituent notionals and curve IDs from reference data. 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 30 of file indexcreditdefaultswapoption.hpp.

Constructor & Destructor Documentation

◆ IndexCreditDefaultSwapOption() [1/2]

IndexCreditDefaultSwapOption ( )

Default constructor.

Definition at line 45 of file indexcreditdefaultswapoption.cpp.

46 : Trade("IndexCreditDefaultSwapOption"), strike_(Null<Real>()) {}

ore::data::IndexCreditDefaultSwapOption::strike_

QuantLib::Real strike_

Definition: indexcreditdefaultswapoption.hpp:76

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

◆ IndexCreditDefaultSwapOption() [2/2]

IndexCreditDefaultSwapOption	(	const ore::data::Envelope &	env,
		const IndexCreditDefaultSwapData &	swap,
		const ore::data::OptionData &	option,
		QuantLib::Real	strike,
		const std::string &	indexTerm = `""`,
		const std::string &	strikeType = `"Spread"`,
		const QuantLib::Date &	tradeDate = `Date()`,
		const QuantLib::Date &	fepStartDate = `Date()`
	)

Detailed 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 55 of file indexcreditdefaultswapoption.cpp.

                                                                                                  {
 
    DLOG("IndexCreditDefaultSwapOption::build() called for trade " << id());
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = string("Credit");
    additionalData_["isdaBaseProduct"] = string("Swaptions");
    string entity = swap_.creditCurveId();
    QuantLib::ext::shared_ptr<ReferenceDataManager> refData = engineFactory->referenceData();
    if (refData && refData->hasData("CreditIndex", entity)) {
        auto refDatum = refData->getData("CreditIndex", entity);
        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 " << entity);
        }
    } else {
        ALOG("Credit index reference data missing for entity " << entity << ", isdaSubProduct left blank");
    }
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = string("");  
 
    // Dates
    const QuantLib::ext::shared_ptr<Market>& market = engineFactory->market();
    Date asof = market->asofDate();
    if (asof == Null<Date>() || asof == Date()) {
        asof = Settings::instance().evaluationDate();
    }
 
    if (tradeDate_ == Date()) {
        tradeDate_ = asof;
    } else {
        QL_REQUIRE(tradeDate_ <= asof, "Trade date (" << io::iso_date(tradeDate_) << ") should be on or "
                                                      << "before the valuation date (" << io::iso_date(asof) << ")");
    }
 
    if (fepStartDate_ == Date()) {
        fepStartDate_ = tradeDate_;
    } else {
        QL_REQUIRE(fepStartDate_ <= tradeDate_, "Front end protection start date ("
                                                    << io::iso_date(fepStartDate_)
                                                    << ") should be on or before the trade date ("
                                                    << io::iso_date(tradeDate_) << ")");
    }
 
    // Option trade notional. This is the full notional of the index that is being traded not reduced by any
    // defaults. The notional on the trade date will be a fraction of this if there are defaults by trade date.
    auto legData = swap_.leg();
    const auto& ntls = legData.notionals();
    QL_REQUIRE(ntls.size() == 1, "IndexCreditDefaultSwapOption requires a single notional.");
    notionals_ = Notionals();
    notionals_.full = ntls.front();
    notionalCurrency_ = legData.currency();
    npvCurrency_ = legData.currency();
 
    // Need fixed leg data with one rate. This should be the standard running coupon on the index CDS e.g.
    // 100bp for CDX IG and 500bp for CDX HY.
    QL_REQUIRE(legData.legType() == "Fixed", "Index 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();
    Real upfrontFee = swap_.upfrontFee();
 
    // Usually, we expect a Strike and StrikeType. However, for backwards compatibility we also allow for
    // empty values and populate Strike, StrikeType from the underlying upfront and coupon.
    QL_REQUIRE(strikeType_ == "" || strikeType_ == "Spread" || strikeType_ == "Price",
               "invalid StrikeType (" << strikeType_ << "), expected 'Spread' or 'Price' or empty value");
    if (strike_ == Null<Real>() && strikeType_ == "" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = runningCoupon;
        effectiveStrikeType_ = "Spread";
    } else if (strike_ == Null<Real>() && strikeType_ == "Spread" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = runningCoupon;
        effectiveStrikeType_ = "Spread";
    } else if (strike_ == Null<Real>() && strikeType_ == "Price" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = 1.0;
        effectiveStrikeType_ = "Price";
    } else if (strike_ != Null<Real>() && strikeType_ == "" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = strike_;
        effectiveStrikeType_ = "Spread";
    } else if (strike_ != Null<Real>() && strikeType_ == "Spread" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = strike_;
        effectiveStrikeType_ = "Spread";
    } else if (strike_ != Null<Real>() && strikeType_ == "Price" && upfrontFee == Null<Real>()) {
        effectiveStrike_ = strike_;
        effectiveStrikeType_ = "Price";
    } else if (strike_ == Null<Real>() && strikeType_ == "" && upfrontFee != Null<Real>()) {
        effectiveStrike_ = 1.0 - upfrontFee;
        effectiveStrikeType_ = "Price";
    } else if (strike_ == Null<Real>() && strikeType_ == "Spread" && upfrontFee != Null<Real>()) {
        if (close_enough(upfrontFee, 0.0)) {
            effectiveStrike_ = runningCoupon;
            effectiveStrikeType_ = "Spread";
        } else {
            QL_FAIL("StrikeType 'Spread' and non-zero upfront fee can not be combined.");
        }
    } else if (strike_ == Null<Real>() && strikeType_ == "Price" && upfrontFee != Null<Real>()) {
        effectiveStrike_ = 1.0 - upfrontFee;
        effectiveStrikeType_ = "Price";
    } else if (strike_ != Null<Real>() && strikeType_ == "" && upfrontFee != Null<Real>()) {
        if (close_enough(upfrontFee, 0.0)) {
            effectiveStrike_ = strike_;
            effectiveStrikeType_ = "Spread";
        } else {
            QL_FAIL("Strike and non-zero upfront can not be combined.");
        }
    } else if (strike_ != Null<Real>() && strikeType_ == "Spread" && upfrontFee != Null<Real>()) {
        if (close_enough(upfrontFee, 0.0)) {
            effectiveStrike_ = strike_;
            effectiveStrikeType_ = "Spread";
        } else {
            QL_FAIL("Strike and non-zero upfront can not be combined.");
        }
    } else if (strike_ != Null<Real>() && strikeType_ == "Price" && upfrontFee != Null<Real>()) {
        if (close_enough(upfrontFee, 0.0)) {
            effectiveStrike_ = strike_;
            effectiveStrikeType_ = "Price";
        } else {
            QL_FAIL("Strike and non-zero upfront can not be combined.");
        }
    } else {
        QL_FAIL("internal error, impossible branch in strike / strike type deduction.");
    }
    DLOG("Will use strike = " << effectiveStrike_ << ", strikeType = " << effectiveStrikeType_);
 
    // Payer (Receiver) swaption if the leg is paying (receiving).
    auto side = legData.isPayer() ? Protection::Side::Buyer : Protection::Side::Seller;
 
    // Populate the constituents and determine the various notional amounts.
    constituents_.clear();
    if (swap_.basket().constituents().size() > 1) {
        fromBasket(asof, constituents_);
    } else {
        fromReferenceData(asof, constituents_, engineFactory->referenceData());
    }
 
    // Transfer to vectors for ctors below
    vector<string> constituentIds;
    constituentIds.reserve(constituents_.size());
    vector<Real> constituentNtls;
    constituentNtls.reserve(constituents_.size());
    for (const auto& kv : constituents_) {
        constituentIds.push_back(kv.first);
        constituentNtls.push_back(kv.second);
    }
 
    // Day counter. In general for CDS and CDS index trades, the standard day counter is Actual/360 and the final
    // period coupon accrual includes the maturity date.
    DayCounter dc = parseDayCounter(legData.dayCounter());
    Actual360 standardDayCounter;
    DayCounter lastPeriodDayCounter = dc == standardDayCounter ? Actual360(true) : dc;
 
    // Checks on the option data
    QL_REQUIRE(option_.style() == "European", "IndexCreditDefaultSwapOption option style must"
                                                  << " be European but got " << option_.style() << ".");
    QL_REQUIRE(option_.exerciseFees().empty(), "IndexCreditDefaultSwapOption cannot handle exercise fees.");
 
    // Exercise must be European
    const auto& exerciseDates = option_.exerciseDates();
    QL_REQUIRE(exerciseDates.size() == 1, "IndexCreditDefaultSwapOption 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);
 
    QL_REQUIRE(parseDate(legData.schedule().rules().front().endDate()) > exerciseDate, 
        "IndexCreditDefaultSwapOption: ExerciseDate must be before EndDate");
 
    // We apply an automatic correction to a common mistake in the input data, where the full index underlying
    // is provided and not only the part of the underlying into which we exercise.
    if (legData.schedule().rules().size() == 1 && legData.schedule().dates().empty()) {
        // The start date should be >= exercise date, this will produce correct coupons for both
        // - post big bang rules CDS, CDS2015 (full first coupon) and
        // - pre big bang rules (short first coupon)
        if (parseDate(legData.schedule().rules().front().startDate()) < exerciseDate) {
            legData.schedule().modifyRules().front().modifyStartDate() = ore::data::to_string(exerciseDate);
        }
    }
 
    // Schedule
    Schedule schedule = makeSchedule(legData.schedule());
    BusinessDayConvention payConvention = parseBusinessDayConvention(legData.paymentConvention());
 
    // Populate trade date and protection start date of underlying swap
    QL_REQUIRE(!schedule.dates().empty(),
               "IndexCreditDefaultSwapOption: underlying swap schedule does not contain any dates");
    Date underlyingTradeDate =
        swap_.tradeDate() == Date() ? std::max(exerciseDate, schedule.dates().front()) : swap_.tradeDate();
    Date underlyingProtectionStart;
    if (swap_.protectionStart() != Date()) {
        underlyingProtectionStart = swap_.protectionStart();
    } else if (legData.schedule().rules().size() == 1 && legData.schedule().dates().empty()) {
        auto rule = parseDateGenerationRule(legData.schedule().rules().front().rule());
        if (rule == DateGeneration::CDS || rule == DateGeneration::CDS2015) {
            underlyingProtectionStart = std::max(exerciseDate, schedule.dates().front());
        } else {
            underlyingProtectionStart = schedule.dates().front();
        }
    } else {
        underlyingProtectionStart = std::max(exerciseDate, schedule.dates().front());
    }
 
    // get engine builders for option and underlying swap
    auto iCdsOptionEngineBuilder = QuantLib::ext::dynamic_pointer_cast<IndexCreditDefaultSwapOptionEngineBuilder>(
        engineFactory->builder("IndexCreditDefaultSwapOption"));
    QL_REQUIRE(iCdsOptionEngineBuilder,
               "IndexCreditDefaultSwapOption: internal error, expected IndexCreditDefaultSwapOptionEngineBuilder");
    auto iCdsEngineBuilder = QuantLib::ext::dynamic_pointer_cast<IndexCreditDefaultSwapEngineBuilder>(
        engineFactory->builder("IndexCreditDefaultSwap"));
    QL_REQUIRE(iCdsEngineBuilder,
               "IndexCreditDefaultSwap: internal error, expected IndexCreditDefaultSwapEngineBuilder");
 
    // The underlying index CDS as it looks on the valuation date i.e. outstanding notional is the valuation
    // date notional and the basket of notionals contains only those reference entities not defaulted (i.e.
    // those with auction date in the future to be more precise).
    auto cds = QuantLib::ext::make_shared<QuantExt::IndexCreditDefaultSwap>(
        side, notionals_.valuationDate, constituentNtls, runningCoupon, schedule, payConvention, dc,
        swap_.settlesAccrual(), swap_.protectionPaymentTime(), underlyingProtectionStart, QuantLib::ext::shared_ptr<Claim>(),
        lastPeriodDayCounter, true, underlyingTradeDate, swap_.cashSettlementDays());
 
    // Set engine on the underlying CDS.
    auto ccy = parseCurrency(npvCurrency_);
    std::string overrideCurve = iCdsOptionEngineBuilder->engineParameter("Curve", {}, false, "Underlying");
 
    auto creditCurveId = this->creditCurveId();
    // warn if that is not possible, except for trades on custom baskets
    if (swap_.basket().constituents().empty() && splitCurveIdWithTenor(creditCurveId).second == 0 * Days) {
        StructuredTradeWarningMessage(id(), tradeType(), "Could not imply Index CDS term.",
                                           "Index CDS term could not be derived from start, end date, are these "
                                           "dates correct (credit curve id is '" +
                                          swap_.creditCurveId() + "')")
            .log();
    }
 
    // for cash settlement build the underlying swap with the inccy discount curve
    Settlement::Type settleType = parseSettlementType(option_.settlement());
    cds->setPricingEngine(iCdsEngineBuilder->engine(ccy, creditCurveId, constituentIds, overrideCurve,
                                                    swap_.recoveryRate(), settleType == Settlement::Cash));
    setSensitivityTemplate(*iCdsEngineBuilder);
 
    // Strike may be in terms of spread or price
    auto strikeType = parseCdsOptionStrikeType(effectiveStrikeType_);
 
    // Determine the index term;
    effectiveIndexTerm_ = 5 * Years;
    if (!indexTerm_.empty()) {
        // if the option has an explicit index term set, we use that
        effectiveIndexTerm_ = parsePeriod(indexTerm_);
    } else {
        // otherwise we derive the index term from the start date (or an externally set hint for that)
        effectiveIndexTerm_ = QuantExt::implyIndexTerm(swap_.indexStartDateHint() == Date() ? schedule.dates().front()
                                                                                        : swap_.indexStartDateHint(),
                                                   schedule.dates().back());
    }
 
    // Build the option
    auto option = QuantLib::ext::make_shared<QuantExt::IndexCdsOption>(cds, exercise, effectiveStrike_, strikeType, settleType,
                                                               notionals_.tradeDate, notionals_.realisedFep,
                                                               effectiveIndexTerm_);
    // the vol curve id is the credit curve id stripped by a term, if the credit curve id should contain one
    auto p = splitCurveIdWithTenor(swap_.creditCurveId());
    volCurveId_ = p.first;
    option->setPricingEngine(iCdsOptionEngineBuilder->engine(ccy, creditCurveId, volCurveId_, constituentIds));
    setSensitivityTemplate(*iCdsOptionEngineBuilder);
 
    // Keep this comment about the maturity date being the underlying maturity instead of the option expiry.
    // [RL] Align option product maturities with ISDA AANA/GRID guidance as of November 2020.
    maturity_ = cds->coupons().back()->date();
 
    // Set Trade members _before_ possibly adding the premium payment below.
    legs_ = {cds->coupons()};
    legCurrencies_ = {npvCurrency_};
    legPayers_ = {legData.isPayer()};
 
    // Long or short the option
    Position::Type positionType = parsePositionType(option_.longShort());
    Real indicatorLongShort = positionType == Position::Long ? 1.0 : -1.0;
 
    // Include premium if enough information is provided
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
    string configuration = iCdsOptionEngineBuilder->configuration(MarketContext::pricing);
    maturity_ =
        std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, indicatorLongShort,
                                        option_.premiumData(), -indicatorLongShort, ccy, engineFactory, configuration));
 
    // Instrument wrapper depends on the settlement type.
    // 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()) {
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(option, indicatorLongShort, additionalInstruments,
                                                            additionalMultipliers);
    } else {
        bool isLong = positionType == Position::Long;
        bool isPhysical = settleType == Settlement::Physical;
        instrument_ = QuantLib::ext::make_shared<EuropeanOptionWrapper>(option, isLong, exerciseDate, isPhysical, cds, 1.0, 1.0,
                                                                additionalInstruments, additionalMultipliers);
    }
 
    sensitivityDecomposition_ = iCdsOptionEngineBuilder->sensitivityDecomposition();
}

Here is the call graph for this function:

◆ notional()

Real notional ( ) const

overridevirtual

Return the current notional in npvCurrency. See individual sub-classes for the precise definition.

Reimplemented from Trade.

Definition at line 358 of file indexcreditdefaultswapoption.cpp.

                                                  {
 
    if (notionals_.valuationDate == Null<Real>()) {
        ALOG("Error retrieving current notional for index credit default swap option "
             << id() << " as of " << Settings::instance().evaluationDate());
    }
 
    return notionals_.valuationDate;
}

◆ fromXML()

void fromXML ( ore::data::XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 368 of file indexcreditdefaultswapoption.cpp.

                                                        {
 
    Trade::fromXML(node);
 
    XMLNode* iCdsOptionData = XMLUtils::getChildNode(node, "IndexCreditDefaultSwapOptionData");
    QL_REQUIRE(iCdsOptionData, "Expected IndexCreditDefaultSwapOptionData node on trade " << id() << ".");
    strike_ = XMLUtils::getChildValueAsDouble(iCdsOptionData, "Strike", false, Null<Real>());
    indexTerm_ = XMLUtils::getChildValue(iCdsOptionData, "IndexTerm", false);
    strikeType_ = XMLUtils::getChildValue(iCdsOptionData, "StrikeType", false);
    tradeDate_ = Date();
    if (auto n = XMLUtils::getChildNode(iCdsOptionData, "TradeDate")) {
        tradeDate_ = parseDate(XMLUtils::getNodeValue(n));
    }
    fepStartDate_ = Date();
    if (auto n = XMLUtils::getChildNode(iCdsOptionData, "FrontEndProtectionStartDate")) {
        fepStartDate_ = parseDate(XMLUtils::getNodeValue(n));
    }
 
    XMLNode* iCdsData = XMLUtils::getChildNode(iCdsOptionData, "IndexCreditDefaultSwapData");
    QL_REQUIRE(iCdsData, "Expected IndexCreditDefaultSwapData node on trade " << id() << ".");
    swap_.fromXML(iCdsData);
 
    XMLNode* optionData = XMLUtils::getChildNode(iCdsOptionData, "OptionData");
    QL_REQUIRE(optionData, "Expected OptionData node on trade " << id() << ".");
    option_.fromXML(optionData);
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( ore::data::XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 395 of file indexcreditdefaultswapoption.cpp.

                                                                   {
 
    // Trade node
    XMLNode* node = Trade::toXML(doc);
 
    // IndexCreditDefaultSwapOptionData node
    XMLNode* iCdsOptionData = doc.allocNode("IndexCreditDefaultSwapOptionData");
    if (strike_ != Null<Real>())
        XMLUtils::addChild(doc, iCdsOptionData, "Strike", strike_);
    if (!indexTerm_.empty())
        XMLUtils::addChild(doc, iCdsOptionData, "IndexTerm", indexTerm_);
    if (strikeType_ != "")
        XMLUtils::addChild(doc, iCdsOptionData, "StrikeType", strikeType_);
    if (tradeDate_ != Date())
        XMLUtils::addChild(doc, iCdsOptionData, "TradeDate", to_string(tradeDate_));
    if (fepStartDate_ != Date())
        XMLUtils::addChild(doc, iCdsOptionData, "FrontEndProtectionStartDate", to_string(fepStartDate_));
 
    XMLUtils::appendNode(iCdsOptionData, swap_.toXML(doc));
    XMLUtils::appendNode(iCdsOptionData, option_.toXML(doc));
 
    // Add IndexCreditDefaultSwapOptionData node to Trade node
    XMLUtils::appendNode(node, iCdsOptionData);
 
    return node;
}

Here is the call graph for this function:

◆ swap()

const IndexCreditDefaultSwapData & swap ( ) const

Definition at line 422 of file indexcreditdefaultswapoption.cpp.

422{ return swap_; }

Here is the caller graph for this function:

◆ option()

const OptionData & option ( ) const

Definition at line 424 of file indexcreditdefaultswapoption.cpp.

424{ return option_; }

Here is the caller graph for this function:

◆ indexTerm()

const std::string & indexTerm ( ) const

Definition at line 426 of file indexcreditdefaultswapoption.cpp.

426{ return indexTerm_; }

◆ strike()

Real strike ( ) const

Definition at line 428 of file indexcreditdefaultswapoption.cpp.

428{ return strike_; }

◆ callPut()

QuantLib::Option::Type callPut ( ) const

Definition at line 430 of file indexcreditdefaultswapoption.cpp.

                                                               {
    if (swap().leg().isPayer())
        return QuantLib::Option::Type::Call;
    else
        return QuantLib::Option::Type::Put;
}

Here is the call graph for this function:

◆ strikeType()

const string & strikeType ( ) const

Definition at line 437 of file indexcreditdefaultswapoption.cpp.

437{ return strikeType_; }

Here is the caller graph for this function:

◆ tradeDate()

const Date & tradeDate ( ) const

Definition at line 439 of file indexcreditdefaultswapoption.cpp.

439{ return tradeDate_; }

◆ fepStartDate()

const Date & fepStartDate ( ) const

Definition at line 441 of file indexcreditdefaultswapoption.cpp.

441{ return fepStartDate_; }

◆ sensitivityDecomposition()

const CreditPortfolioSensitivityDecomposition sensitivityDecomposition ( ) const

Definition at line 650 of file indexcreditdefaultswapoption.cpp.

                                                                                                           {
    return sensitivityDecomposition_;
}

◆ effectiveStrike()

QuantLib::Real effectiveStrike ( ) const

Definition at line 654 of file indexcreditdefaultswapoption.cpp.

654{ return effectiveStrike_; }

◆ effectiveStrikeType()

const std::string & effectiveStrikeType ( ) const

Definition at line 656 of file indexcreditdefaultswapoption.cpp.

656{ return effectiveStrikeType_; }

◆ effectiveIndexTerm()

const QuantLib::Period & effectiveIndexTerm ( ) const

Definition at line 658 of file indexcreditdefaultswapoption.cpp.

658{ return effectiveIndexTerm_; }

◆ creditCurveId()

std::string creditCurveId ( ) const

Definition at line 660 of file indexcreditdefaultswapoption.cpp.

                                                            {
    auto p = splitCurveIdWithTenor(swap_.creditCurveId());
    if (p.second != 0 * Days) {
        // if the credit curve id has a suffix "_5Y" already, we use that
        return swap_.creditCurveId();
    } else if (!indexTerm_.empty()) {
        // if not and we have a term we use that
        return p.first + "_" + indexTerm_;
    } else {
        // if not we imply the term from the swap schedule
        return swap_.creditCurveIdWithTerm();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ volCurveId()

const std::string & volCurveId ( ) const

Definition at line 674 of file indexcreditdefaultswapoption.cpp.

674{ return volCurveId_; }

◆ constituents()

const map< string, Real > & constituents ( ) const

Definition at line 676 of file indexcreditdefaultswapoption.cpp.

676{ return constituents_; };

Here is the caller graph for this function:

◆ fromBasket()

void fromBasket	(	const QuantLib::Date &	asof,
		std::map< std::string, QuantLib::Real > &	constituents
	)

private

Populate constituent notionals and curve IDs from basket data.

Definition at line 443 of file indexcreditdefaultswapoption.cpp.

                                                                                                  {
 
    const auto& constituents = swap_.basket().constituents();
    DLOG("Building constituents from basket data containing " << constituents.size() << " elements.");
 
    Real totalNtl = 0.0;
    Real fullNtl = notionals_.full;
    for (const auto& c : constituents) {
        Real ntl = Null<Real>();
        Real priorNotional = Null<Real>();
 
        const auto& creditCurve = c.creditCurveId();
 
        if (c.weightInsteadOfNotional()) {
            ntl = c.weight() * fullNtl;
        } else {
            ntl = c.notional();
        }
 
        if (ntl == 0.0 || close(0.0, ntl)) {
            if (c.weightInsteadOfNotional()) {
                priorNotional = c.priorWeight();
                if (priorNotional != Null<Real>()) {
                    priorNotional *= fullNtl;
                }
            } else {
                priorNotional = c.priorNotional();
            }
            // Entity is not in the index. Its auction date is in the past.
            QL_REQUIRE(priorNotional != Null<Real>(), "Constituent "
                                                          << creditCurve << " in index CDS option trade " << id()
                                                          << " has defaulted so expecting a prior notional.");
            QL_REQUIRE(c.recovery() != Null<Real>(), "Constituent " << creditCurve << " in index CDS option trade "
                                                                    << id()
                                                                    << " has defaulted so expecting a recovery.");
            QL_REQUIRE(c.auctionDate() != Date(), "Constituent " << creditCurve << " in index CDS option trade " << id()
                                                                 << " has defaulted so expecting an auction date.");
            QL_REQUIRE(c.auctionDate() <= asof, "Constituent " << creditCurve << " in index CDS option trade " << id()
                                                               << " has defaulted so expecting the auction date ("
                                                               << io::iso_date(c.auctionDate())
                                                               << ") to be before or on the valuation date ("
                                                               << io::iso_date(asof) << ".");
 
            totalNtl += priorNotional * notional_;
 
            if (tradeDate_ < c.auctionDate()) {
                TLOG("Trade date (" << io::iso_date(tradeDate_) << ") is before auction date ("
                                    << io::iso_date(c.auctionDate()) << ") of " << creditCurve
                                    << " so updating trade date "
                                    << "notional by amount " << priorNotional);
                notionals_.tradeDate += priorNotional;
            }
 
            if (fepStartDate_ < c.auctionDate()) {
                Real recovery = swap_.recoveryRate() != Null<Real>() ? swap_.recoveryRate() : c.recovery();
                Real fepAmount = (1 - recovery) * priorNotional;
                TLOG("FEP start date (" << io::iso_date(fepStartDate_) << ") is before auction date ("
                                        << io::iso_date(c.auctionDate()) << ") of " << creditCurve
                                        << " so updating realised "
                                        << "FEP by amount " << fepAmount);
                notionals_.realisedFep += fepAmount;
            }
 
        } else if (ntl > 0.0) {
 
            // Entity is still in the index.
            // Note that it may have defaulted but its auction date is still in the future.
            auto it = outConstituents.find(creditCurve);
            if (it == outConstituents.end()) {
                outConstituents[creditCurve] = ntl;
                TLOG("Adding underlying " << creditCurve << " with notional " << ntl);
                totalNtl += ntl;
                notionals_.tradeDate += ntl;
                notionals_.valuationDate += ntl;
            } else {
                StructuredTradeErrorMessage(id(), "IndexCDSOption", "Error building trade",
                                                 ("Invalid Basket: found a duplicate credit curve " + creditCurve +
                                                  ".Skip it. Check the basket data for possible errors.")
                                                .c_str())
                    .log();
            }
        } else {
            QL_FAIL("Constituent " << creditCurve << " in index CDS option trade " << id()
                                   << " has a negative notional " << ntl << ".");
        }
    }
 
    Real correctionFactor = fullNtl / totalNtl;
    // Scaling to Notional if relative error is close less than 10^-4
    if (!close(fullNtl, totalNtl) && (std::abs(correctionFactor - 1.0) <= 1e-4)) {
        DLOG("Trade " << id() << ", sum of notionals (" << totalNtl << ") is very close to " << fullNtl
                      << ",will scale it by " << correctionFactor << ". Check the basket data for possible errors.");
 
        for (auto& name_notional : outConstituents) {
            TLOG("Trade " << id() << ", Issuer" << name_notional.first << " unscaled Notional: " << name_notional.second
                          << ", scaled Notional: " << name_notional.second * correctionFactor);
            name_notional.second *= correctionFactor;
        }
 
        totalNtl *= correctionFactor;
        notionals_.tradeDate *= correctionFactor;
        notionals_.valuationDate *= correctionFactor;
        notionals_.realisedFep *= correctionFactor;
    }
 
    DLOG("All underlyings added, total notional = " << totalNtl);
    if (!close(fullNtl, totalNtl) && totalNtl > fullNtl) {
        StructuredTradeErrorMessage(id(), "IndexCDSOption", "Error building trade",
                                         ("Sum of basket notionals (" + std::to_string(totalNtl) +
                                          ") is greater than trade notional (" + std::to_string(fullNtl) +
                                          "). Check the basket data for possible errors.")
                                        .c_str())
            .log();
    }
 
    DLOG("Finished building constituents using basket data.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromReferenceData()

void fromReferenceData	(	const QuantLib::Date &	asof,
		std::map< std::string, QuantLib::Real > &	constituents,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	refData
	)

private

Populate constituent notionals and curve IDs from reference data.

Definition at line 561 of file indexcreditdefaultswapoption.cpp.

                                                                                                                 {
 
    const string& iCdsId = swap_.creditCurveId();
    DLOG("Start building constituents using credit reference data for " << iCdsId << ".");
 
    QL_REQUIRE(refData, "Building index CDS option " << id() << " ReferenceDataManager is null.");
    QL_REQUIRE(refData->hasData(CreditIndexReferenceDatum::TYPE, iCdsId),
               "No CreditIndex reference data for " << iCdsId);
    auto referenceData = QuantLib::ext::dynamic_pointer_cast<CreditIndexReferenceDatum>(
        refData->getData(CreditIndexReferenceDatum::TYPE, iCdsId));
    DLOG("Got CreditIndexReferenceDatum for id " << iCdsId);
 
    Real fullNtl = notionals_.full;
    Real totalWeight = 0.0;
    for (const auto& c : referenceData->constituents()) {
 
        const auto& name = c.name();
        auto weight = c.weight();
 
        if (weight == 0.0 || close(0.0, weight)) {
 
            // Entity is not in the index. Its auction date is in the past.
            QL_REQUIRE(c.priorWeight() != Null<Real>(), "Constituent "
                                                            << name << " in index CDS option trade " << id()
                                                            << " has defaulted so expecting a prior weight.");
            QL_REQUIRE(c.recovery() != Null<Real>(), "Constituent " << name << " in index CDS option trade " << id()
                                                                    << " has defaulted so expecting a recovery.");
            QL_REQUIRE(c.auctionDate() != Date(), "Constituent " << name << " in index CDS option trade " << id()
                                                                 << " has defaulted so expecting an auction date.");
            QL_REQUIRE(c.auctionDate() <= asof, "Constituent " << name << " in index CDS option trade " << id()
                                                               << " has defaulted so expecting the auction date ("
                                                               << io::iso_date(c.auctionDate())
                                                               << ") to be before or on the valuation date ("
                                                               << io::iso_date(asof) << ").");
 
            totalWeight += c.priorWeight();
 
            if (tradeDate_ < c.auctionDate()) {
                Real entityNtl = c.priorWeight() * fullNtl;
                TLOG("Trade date (" << io::iso_date(tradeDate_) << ") is before auction date ("
                                    << io::iso_date(c.auctionDate()) << ") of " << name << " so updating trade date "
                                    << "notional by amount " << entityNtl);
                notionals_.tradeDate += entityNtl;
            }
 
            if (fepStartDate_ < c.auctionDate()) {
                Real recovery = swap_.recoveryRate() != Null<Real>() ? swap_.recoveryRate() : c.recovery();
                Real fepAmount = (1 - recovery) * c.priorWeight() * fullNtl;
                TLOG("FEP start date (" << io::iso_date(fepStartDate_) << ") is before auction date ("
                                        << io::iso_date(c.auctionDate()) << ") of " << name << " so updating realised "
                                        << "FEP by amount " << fepAmount);
                notionals_.realisedFep += fepAmount;
            }
 
        } else if (weight > 0.0) {
 
            // Entity is still in the index.
            // Note that it may have defaulted but its auction date is still in the future.
            Real entityNtl = weight * fullNtl;
            auto it = outConstituents.find(name);
            if (it == outConstituents.end()) {
                outConstituents[name] = entityNtl;
                TLOG("Adding underlying " << name << " with weight " << weight << " (notional = " << entityNtl << ")");
            } else {
                it->second += entityNtl;
                TLOG("Updating underlying " << name << " with weight " << weight << " (notional = " << entityNtl
                                            << ")");
            }
 
            totalWeight += weight;
            notionals_.tradeDate += entityNtl;
            notionals_.valuationDate += entityNtl;
 
        } else {
            QL_FAIL("Constituent " << name << " in index CDS option trade " << id() << " has a negative weight "
                                   << weight << ".");
        }
    }
 
    DLOG("All underlyings added, total weight = " << totalWeight);
    if (!close(1.0, totalWeight) && totalWeight > 1.0) {
        ALOG("Total weight is greater than 1, possible error in CreditIndexReferenceDatum for "
             << iCdsId << " while building constituents for trade " << id() << ".");
    }
 
    DLOG("Finished building constituents using credit reference data.");
}