#include <ored/portfolio/swaption.hpp>

Inheritance diagram for Swaption:

Collaboration diagram for Swaption:

Public Member Functions
	Swaption ()

	Swaption (const Envelope &env, const OptionData &optionData, const vector< LegData > &legData)

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

Inspectors
const OptionData &	optionData () const

const vector< LegData > &	legData ()

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

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

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	optionData_

vector< LegData >	legData_

QuantLib::ext::shared_ptr< ore::data::Swap >	underlying_

QuantLib::ext::shared_ptr< ExerciseBuilder >	exerciseBuilder_

Position::Type	positionType_

Exercise::Type	exerciseType_

Settlement::Type	settlementType_

Settlement::Method	settlementMethod_

virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

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

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

bool	hasCashflows () const override

bool	isExercised () const

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

std::vector< QuantLib::ext::shared_ptr< Instrument > >	buildUnderlyingSwaps (const QuantLib::ext::shared_ptr< PricingEngine > &, const std::vector< Date > &)
	build underlying swaps for exposure simulation 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

Serializable Swaption.

Definition at line 39 of file swaption.hpp.

Constructor & Destructor Documentation

◆ Swaption() [1/2]

Swaption ( )

Definition at line 41 of file swaption.hpp.

41: Trade("Swaption") {}

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

◆ Swaption() [2/2]

Swaption	(	const Envelope &	env,
		const OptionData &	optionData,
		const vector< LegData > &	legData
	)

Definition at line 42 of file swaption.hpp.

43 : Trade("Swaption", env), optionData_(optionData), legData_(legData) {}

ore::data::Swaption::optionData_

OptionData optionData_

Definition: swaption.hpp:69

ore::data::Swaption::legData_

vector< LegData > legData_

Definition: swaption.hpp:70

ore::data::Swaption::legData

const vector< LegData > & legData()

Definition: swaption.hpp:50

ore::data::Swaption::optionData

const OptionData & optionData() const

Definition: swaption.hpp:49

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 62 of file swaption.cpp.

                                                                              {
 
    DLOG("Swaption::build() for " << id());
 
    // 1 ISDA taxonomy
 
    additionalData_["isdaAssetClass"] = string("Interest Rate");
    additionalData_["isdaBaseProduct"] = string("Option");
    additionalData_["isdaSubProduct"] = string("Swaption");
    additionalData_["isdaTransaction"] = string("");
 
    // 4 fill currencies and set notional to null (will be retrieved via notional())
 
    npvCurrency_ = notionalCurrency_ = "USD"; // only if no legs are given, not relevant in this case
 
    if (!legData_.empty()) {
        npvCurrency_ = notionalCurrency_ = legData_[0].currency();
    }
 
    // 2 build underlying swap and copy its required fixings
 
    underlying_ = QuantLib::ext::make_shared<ore::data::Swap>(Envelope(), legData_);
    underlying_->build(engineFactory);
    requiredFixings_.addData(underlying_->requiredFixings());
 
    // 3 build the exercise and parse some fields
 
    DLOG("Swaption::build() for " << id() << ": build exercise");
 
    exerciseBuilder_ = QuantLib::ext::make_shared<ExerciseBuilder>(optionData_, underlying_->legs());
 
    exerciseType_ = parseExerciseType(optionData_.style());
    settlementType_ = parseSettlementType(optionData_.settlement());
    settlementMethod_ = optionData_.settlementMethod() == "" ? defaultSettlementMethod(settlementType_)
                                                             : parseSettlementMethod(optionData_.settlementMethod());
    positionType_ = parsePositionType(optionData_.longShort());
 
    notional_ = Null<Real>();
 
    Date today = Settings::instance().evaluationDate();
 
    // 5 if the swaption is exercised (as per option data / exercise data), build the cashflows that remain to be paid
 
    if (exerciseBuilder_->isExercised()) {
        Date exerciseDate = exerciseBuilder_->exerciseDate();
        maturity_ = std::max(today, exerciseDate); // will be updated below
 
        if (optionData_.settlement() == "Physical") {
 
            // 5.1 if physical exercise, inlcude the "exercise-into" cashflows of the underlying
 
            for (Size i = 0; i < underlying_->legs().size(); ++i) {
                legs_.push_back(Leg());
                legCurrencies_.push_back(underlying_->legCurrencies()[i]);
                legPayers_.push_back(underlying_->legPayers()[i]);
                for (auto const& c : underlying_->legs()[i]) {
                    if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(c)) {
                        if (exerciseDate <= cpn->accrualStartDate()) {
                            legs_.back().push_back(c);
                            maturity_ = std::max(maturity_, c->date());
                            if (notional_ == Null<Real>())
                                notional_ = cpn->nominal();
                        }
                    } else if (exerciseDate <= c->date()) {
                        legs_.back().push_back(c);
                        maturity_ = std::max(maturity_, c->date());
                    }
                }
            }
 
        } else {
 
            // 5.2 if cash exercise, include the cashSettlement payment
 
            if (exerciseBuilder_->cashSettlement()) {
                legs_.push_back(Leg());
                legs_.back().push_back(exerciseBuilder_->cashSettlement());
                legCurrencies_.push_back(npvCurrency_);
                legPayers_.push_back(false);
                maturity_ = std::max(maturity_, exerciseBuilder_->cashSettlement()->date());
            }
        }
 
        // 5.3 include the exercise fee payment
 
        if (exerciseBuilder_->feeSettlement()) {
            legs_.push_back(Leg());
            legs_.back().push_back(exerciseBuilder_->feeSettlement());
            legCurrencies_.push_back(npvCurrency_);
            legPayers_.push_back(true);
            maturity_ = std::max(maturity_, exerciseBuilder_->feeSettlement()->date());
        }
 
        // 5.4 add unconditional premiums, build instrument (as swap) and exit
 
        std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
        std::vector<Real> additionalMultipliers;
        Date lastPremiumDate = addPremiums(additionalInstruments, additionalMultipliers, Position::Long ? 1.0 : -1.0,
                                           optionData_.premiumData(), positionType_ == Position::Long ? -1.0 : 1.0,
                                           parseCurrency(npvCurrency_), engineFactory,
                                           engineFactory->configuration(MarketContext::pricing));
        auto builder = QuantLib::ext::dynamic_pointer_cast<SwapEngineBuilderBase>(engineFactory->builder("Swap"));
        QL_REQUIRE(builder, "could not get swap builder to build exercised swaption instrument.");
        auto swap = QuantLib::ext::make_shared<QuantLib::Swap>(legs_, legPayers_);
        swap->setPricingEngine(builder->engine(parseCurrency(npvCurrency_),
                                               envelope().additionalField("discount_curve", false),
                                               envelope().additionalField("security_spread", false)));
        setSensitivityTemplate(*builder);
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(swap, positionType_ == Position::Long ? 1.0 : -1.0,
                                                            additionalInstruments, additionalMultipliers);
        maturity_ = std::max(maturity_, lastPremiumDate);
        DLOG("Building exercised swaption done.");
        return;
    }
 
    // 6 if we do not have an active exercise as of today, or no underlying legs we only build unconditional premiums
 
    if (exerciseBuilder_->exercise() == nullptr || exerciseBuilder_->exercise()->dates().empty() ||
        exerciseBuilder_->exercise()->dates().back() <= today || legData_.empty()) {
        legs_ = {{QuantLib::ext::make_shared<QuantLib::SimpleCashFlow>(0.0, today)}};
        legCurrencies_.push_back(npvCurrency_);
        legPayers_.push_back(false);
        maturity_ = today;
        std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
        std::vector<Real> additionalMultipliers;
        Date lastPremiumDate = addPremiums(additionalInstruments, additionalMultipliers, Position::Long ? 1.0 : -1.0,
                                           optionData_.premiumData(), positionType_ == Position::Long ? -1.0 : 1.0,
                                           parseCurrency(npvCurrency_), engineFactory,
                                           engineFactory->configuration(MarketContext::pricing));
        auto builder = QuantLib::ext::dynamic_pointer_cast<SwapEngineBuilderBase>(engineFactory->builder("Swap"));
        QL_REQUIRE(builder, "could not get swap builder to build expired swaption instrument.");
        auto swap = QuantLib::ext::make_shared<QuantLib::Swap>(legs_, legPayers_);
        swap->setPricingEngine(builder->engine(parseCurrency(npvCurrency_),
                                               envelope().additionalField("discount_curve", false),
                                               envelope().additionalField("security_spread", false)));
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(swap, positionType_ == Position::Long ? 1.0 : -1.0,
                                                            additionalInstruments, additionalMultipliers);
        setSensitivityTemplate(*builder);
        maturity_ = std::max(maturity_, lastPremiumDate);
        DLOG("Building (non-exercised) swaption without alive exercise dates done.");
        return;
    }
 
    // 7 fill legs, only include coupons after first exercise
 
    legCurrencies_ = underlying_->legCurrencies();
    legPayers_ = underlying_->legPayers();
    legs_.clear();
    Date firstExerciseDate = exerciseBuilder_->exercise()->dates().front();
    for (auto const& l : underlying_->legs()) {
        legs_.push_back(Leg());
        for (auto const& c : l) {
            if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(c)) {
                if (firstExerciseDate <= cpn->accrualStartDate()) {
                    legs_.back().push_back(c);
                }
            } else if (firstExerciseDate <= c->date()) {
                legs_.back().push_back(c);
            }
        }
    }
 
    // 8 build swaption
 
    if (settlementType_ == Settlement::Physical)
        maturity_ = underlying_->maturity();
    else
        maturity_ = exerciseBuilder_->noticeDates().back();
 
    if (exerciseType_ != Exercise::European && settlementType_ == Settlement::Cash &&
        settlementMethod_ == Settlement::ParYieldCurve)
        WLOG("Cash-settled Bermudan/American Swaption (id = "
             << id() << ") with ParYieldCurve settlement method not supported by Lgm engine. "
             << "Approximate pricing using CollateralizedCashPrice pricing methodology");
 
    std::vector<QuantLib::Currency> ccys;
    for (auto const& c : underlying_->legCurrencies())
        ccys.push_back(parseCurrency(c));
    auto swaption =
        QuantLib::ext::make_shared<QuantExt::MultiLegOption>(underlying_->legs(), underlying_->legPayers(), ccys,
                                                     exerciseBuilder_->exercise(), settlementType_, settlementMethod_);
 
    std::string builderType;
    std::vector<std::string> builderPrecheckMessages;
    // for European swaptions that are not handled by the black pricer, we fall back to the numeric Bermudan pricer
    if (exerciseType_ == Exercise::European &&
        QuantExt::BlackMultiLegOptionEngineBase::instrumentIsHandled(*swaption, builderPrecheckMessages)) {
        builderType = "EuropeanSwaption";
    } else {
        QL_REQUIRE(
            QuantExt::NumericLgmMultiLegOptionEngineBase::instrumentIsHandled(*swaption, builderPrecheckMessages),
            "Swaption::build(): instrument is not handled by the available engines: " +
                boost::join(builderPrecheckMessages, ", "));
        if (exerciseType_ == Exercise::European || exerciseType_ == Exercise::Bermudan)
            builderType = "BermudanSwaption";
        else if (exerciseType_ == Exercise::American)
            builderType = "AmericanSwaption";
    }
 
    DLOG("Getting builder for '" << builderType << "', got " << builderPrecheckMessages.size()
                                 << " builder precheck messages:");
    for (auto const& m : builderPrecheckMessages) {
        DLOG(m);
    }
 
    auto swaptionBuilder = QuantLib::ext::dynamic_pointer_cast<SwaptionEngineBuilder>(engineFactory->builder(builderType));
    QL_REQUIRE(swaptionBuilder, "Swaption::build(): internal error: could not cast to SwaptionEngineBuilder");
 
    auto swapBuilder = QuantLib::ext::dynamic_pointer_cast<SwapEngineBuilderBase>(engineFactory->builder("Swap"));
    QL_REQUIRE(swapBuilder, "Swaption::build(): internal error: could not cast to SwapEngineBuilder");
 
    // 9.1  determine index (if several, pick first) got get the engine
 
    QuantLib::ext::shared_ptr<InterestRateIndex> index;
 
    for (auto const& l : underlying_->legs()) {
        for (auto const& c : l) {
            if (auto cpn = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(c)) {
                if (index == nullptr) {
                    if (auto tmp = QuantLib::ext::dynamic_pointer_cast<IborIndex>(cpn->index())) {
                        DLOG("found ibor / ois index '" << tmp->name() << "'");
                        index = tmp;
                    } else if (auto tmp = QuantLib::ext::dynamic_pointer_cast<SwapIndex>(cpn->index())) {
                        DLOG("found cms index " << tmp->name() << ", use key '" << tmp->iborIndex()->name()
                                                << "' to look up vol");
                        index = tmp->iborIndex();
                    } else if (auto tmp = QuantLib::ext::dynamic_pointer_cast<BMAIndex>(cpn->index())) {
                        DLOG("found bma/sifma index '" << tmp->name() << "'");
                        index = tmp;
                    }
                }
            }
        }
    }
 
    if (index == nullptr) {
        DLOG("no ibor, ois, bma/sifma, cms index found, use ccy key to look up vol");
    }
 
    // 9.2 determine strikes for calibration basket (simple approach, a la summit)
 
    std::vector<Real> strikes(exerciseBuilder_->noticeDates().size(), Null<Real>());
    for (Size i = 0; i < exerciseBuilder_->noticeDates().size(); ++i) {
        Real firstFixedRate = Null<Real>(), lastFixedRate = Null<Real>();
        Real firstFloatSpread = Null<Real>(), lastFloatSpread = Null<Real>();
        for (auto const& l : underlying_->legs()) {
            for (auto const& c : l) {
                if (auto cpn = QuantLib::ext::dynamic_pointer_cast<FixedRateCoupon>(c)) {
                    if (cpn->accrualStartDate() >= exerciseBuilder_->noticeDates()[i] && firstFixedRate == Null<Real>())
                        firstFixedRate = cpn->rate();
                    lastFixedRate = cpn->rate();
                } else if (auto cpn = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(c)) {
                    if (cpn->accrualStartDate() >= exerciseBuilder_->noticeDates()[i] &&
                        firstFloatSpread == Null<Real>())
                        firstFloatSpread = cpn->spread();
                    lastFloatSpread = cpn->spread();
                    if (index == nullptr) {
                        if (auto tmp = QuantLib::ext::dynamic_pointer_cast<IborIndex>(cpn->index())) {
                            DLOG("found ibor / ois index '" << tmp->name() << "'");
                            index = tmp;
                        } else if (auto tmp = QuantLib::ext::dynamic_pointer_cast<SwapIndex>(cpn->index())) {
                            DLOG("found cms index " << tmp->name() << ", use key '" << tmp->iborIndex()->name()
                                                    << "' to look up vol");
                            index = tmp->iborIndex();
                        } else if (auto tmp = QuantLib::ext::dynamic_pointer_cast<BMAIndex>(cpn->index())) {
                            DLOG("found bma/sifma index '" << tmp->name() << "'");
                            index = tmp;
                        }
                    }
                }
            }
        }
        // if no first fixed rate (float spread) was found, fall back on the last values
        if(firstFixedRate == Null<Real>())
            firstFixedRate = lastFixedRate;
        if(firstFloatSpread == Null<Real>())
            firstFloatSpread = lastFloatSpread;
        // construct calibration strike
        if (firstFixedRate != Null<Real>()) {
            strikes[i] = firstFixedRate;
            if (firstFloatSpread != Null<Real>()) {
                strikes[i] -= firstFloatSpread;
            }
        }
        DLOG("calibration strike for ex date "
             << QuantLib::io::iso_date(exerciseBuilder_->noticeDates()[i]) << " is "
             << (strikes[i] == Null<Real>() ? "ATMF" : std::to_string(strikes[i])) << " (fixed rate "
             << (firstFixedRate == Null<Real>() ? "NA" : std::to_string(firstFixedRate)) << ", spread "
             << (firstFloatSpread == Null<Real>() ? "NA" : std::to_string(firstFloatSpread)) << ")");
    }
 
    // 9.3 get engine and set it
 
    cpu_timer timer;
    // use ibor / ois index as key, if possible, otherwise the npv currency
    auto swaptionEngine = swaptionBuilder->engine(
        id(), index == nullptr ? npvCurrency_ : IndexNameTranslator::instance().oreName(index->name()),
        exerciseBuilder_->noticeDates(), underlying_->maturity(), strikes, exerciseType_ == Exercise::American,
        envelope().additionalField("discount_curve", false), envelope().additionalField("security_spread", false));
    timer.stop();
    DLOG("Swaption model calibration time: " << timer.format(default_places, "%w") << " s");
    swaption->setPricingEngine(swaptionEngine);
    setSensitivityTemplate(*swaptionBuilder);
 
    // 9.4 build underlying swaps, add premiums, build option wrapper
 
    auto swapEngine =
        swapBuilder->engine(parseCurrency(npvCurrency_), envelope().additionalField("discount_curve", false),
                            envelope().additionalField("security_spread", false));
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> underlyingSwaps =
        buildUnderlyingSwaps(swapEngine, exerciseBuilder_->noticeDates());
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    Real multiplier = positionType_ == Position::Long ? 1.0 : -1.0;
    Date lastPremiumDate = addPremiums(additionalInstruments, additionalMultipliers, Position::Long ? 1.0 : -1.0,
                                       optionData_.premiumData(), -multiplier, parseCurrency(npvCurrency_),
                                       engineFactory, swaptionBuilder->configuration(MarketContext::pricing));
 
    instrument_ = QuantLib::ext::make_shared<BermudanOptionWrapper>(
        swaption, positionType_ == Position::Long ? true : false, exerciseBuilder_->noticeDates(),
        settlementType_ == Settlement::Physical ? true : false, underlyingSwaps, 1.0, 1.0, additionalInstruments,
        additionalMultipliers);
 
    maturity_ = std::max(maturity_, lastPremiumDate);
 
    DLOG("Building Swaption done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ optionData()

const OptionData & optionData ( ) const

Definition at line 49 of file swaption.hpp.

49{ return optionData_; }

Here is the caller graph for this function:

◆ legData()

const vector< LegData > & legData ( )

Definition at line 50 of file swaption.hpp.

50{ return legData_; }

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Reimplemented from Trade.

Definition at line 483 of file swaption.cpp.

                                    {
    Trade::fromXML(node);
    XMLNode* swapNode = XMLUtils::getChildNode(node, "SwaptionData");
    optionData_.fromXML(XMLUtils::getChildNode(swapNode, "OptionData"));
    legData_.clear();
    vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(swapNode, "LegData");
    for (Size i = 0; i < nodes.size(); i++) {
        LegData ld;
        ld.fromXML(nodes[i]);
        legData_.push_back(ld);
    }
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Reimplemented from Trade.

Definition at line 496 of file swaption.cpp.

                                               {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* swaptionNode = doc.allocNode("SwaptionData");
    XMLUtils::appendNode(node, swaptionNode);
 
    XMLUtils::appendNode(swaptionNode, optionData_.toXML(doc));
    for (Size i = 0; i < legData_.size(); i++)
        XMLUtils::appendNode(swaptionNode, legData_[i].toXML(doc));
 
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notional()

QuantLib::Real notional ( ) const

overridevirtual

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

Reimplemented from Trade.

Definition at line 437 of file swaption.cpp.

                                      {
    Real tmp = 0.0;
    for (auto const& l : underlying_->legs()) {
        tmp = std::max(tmp, currentNotional(l));
    }
    return tmp;
}

Here is the call graph for this function:

◆ additionalData()

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

overridevirtual

returns all additional data returned by the trade once built

Reimplemented from Trade.

Definition at line 447 of file swaption.cpp.

                                                                  {
    // use the build time as of date to determine current notionals
    Date asof = Settings::instance().evaluationDate();
    for (Size i = 0; i < std::min(legData_.size(), legs_.size()); ++i) {
        string legID = to_string(i + 1);
        additionalData_["legType[" + legID + "]"] = legData_[i].legType();
        additionalData_["isPayer[" + legID + "]"] = legData_[i].isPayer();
        additionalData_["notionalCurrency[" + legID + "]"] = legData_[i].currency();
        for (Size j = 0; j < legs_[i].size(); ++j) {
            QuantLib::ext::shared_ptr<CashFlow> flow = legs_[i][j];
            // pick flow with earliest future payment date on this leg
            if (flow->date() > asof) {
                additionalData_["amount[" + legID + "]"] = flow->amount();
                additionalData_["paymentDate[" + legID + "]"] = to_string(flow->date());
                QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(flow);
                if (coupon) {
                    additionalData_["currentNotional[" + legID + "]"] = coupon->nominal();
                    additionalData_["rate[" + legID + "]"] = coupon->rate();
                    QuantLib::ext::shared_ptr<FloatingRateCoupon> frc = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(flow);
                    if (frc) {
                        additionalData_["index[" + legID + "]"] = frc->index()->name();
                        additionalData_["spread[" + legID + "]"] = frc->spread();
                    }
                }
                break;
            }
        }
        if (legs_[i].size() > 0) {
            QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(legs_[i][0]);
            if (coupon)
                additionalData_["originalNotional[" + legID + "]"] = coupon->nominal();
        }
    }
    return additionalData_;
}

Here is the call graph for this function:

◆ hasCashflows()

bool hasCashflows ( ) const

overridevirtual

Utility method indicating if the trade has cashflows for the cashflow report. The default implementation returns true so that a trade is automatically considered when cashflows are being written. To prevent a trade from being asked for its cashflows, the method can be overridden to return false.

Reimplemented from Trade.

Definition at line 61 of file swaption.hpp.

61{ return false; }

◆ isExercised()

bool isExercised ( ) const

Definition at line 445 of file swaption.cpp.

445{ return exerciseBuilder_->isExercised(); }

Here is the caller graph for this function:

◆ underlyingIndices()

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

overridevirtual

Reimplemented from Trade.

Definition at line 509 of file swaption.cpp.

                                                                                                         {
    map<AssetClass, set<string>> result;
    if (auto s = envelope().additionalField("security_spread", false); !s.empty())
        result[AssetClass::BOND] = {s};
    return result;
}

Here is the call graph for this function:

◆ buildUnderlyingSwaps()

std::vector< QuantLib::ext::shared_ptr< Instrument > > buildUnderlyingSwaps	(	const QuantLib::ext::shared_ptr< PricingEngine > &	swapEngine,
		const std::vector< Date > &	exerciseDates
	)

private

build underlying swaps for exposure simulation

Definition at line 393 of file swaption.cpp.

                                                                     {
    std::vector<QuantLib::ext::shared_ptr<Instrument>> swaps;
    for (Size i = 0; i < exerciseDates.size(); ++i) {
        std::vector<Leg> legs = underlying_->legs();
        std::vector<bool> payer = underlying_->legPayers();
        for (Size j = 0; j < legs.size(); ++j) {
            Date ed = exerciseDates[i];
            auto it = std::lower_bound(legs[j].begin(), legs[j].end(), exerciseDates[i],
                                       [&ed](const QuantLib::ext::shared_ptr<CashFlow>& c, const Date& d) {
                                           if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(c)) {
                                               return cpn->accrualStartDate() < ed;
                                           } else {
                                               return c->date() < ed;
                                           }
                                       });
            if (it != legs[j].begin())
                --it;
            legs[j].erase(legs[j].begin(), it);
        }
        auto newSwap = QuantLib::ext::make_shared<QuantLib::Swap>(legs, payer);
        if (swapEngine != nullptr) {
            newSwap->setPricingEngine(swapEngine);
        }
        swaps.push_back(newSwap);
        for (auto const& l : legs) {
            if (l.empty()) {
                WLOG("Added empty leg to underlying swap for exercise " << QuantLib::io::iso_date(exerciseDates[i])
                                                                        << "!");
            } else {
                Date d;
                if (auto cpn = QuantLib::ext::dynamic_pointer_cast<Coupon>(l.front())) {
                    d = cpn->accrualStartDate();
                } else {
                    d = l.front()->date();
                }
                DLOG("Added leg with start date " << QuantLib::io::iso_date(d) << " for exercise "
                                                  << QuantLib::io::iso_date(exerciseDates[i]));
            }
        }
    }
    return swaps;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ optionData_

OptionData optionData_

private

Definition at line 69 of file swaption.hpp.

◆ legData_

vector<LegData> legData_

private

Definition at line 70 of file swaption.hpp.

◆ underlying_

QuantLib::ext::shared_ptr<ore::data::Swap> underlying_

private

Definition at line 76 of file swaption.hpp.

◆ exerciseBuilder_

QuantLib::ext::shared_ptr<ExerciseBuilder> exerciseBuilder_

private

Definition at line 77 of file swaption.hpp.

◆ positionType_

Position::Type positionType_

private

Definition at line 78 of file swaption.hpp.

◆ exerciseType_

Exercise::Type exerciseType_

private

Definition at line 79 of file swaption.hpp.

◆ settlementType_

Settlement::Type settlementType_

private

Definition at line 80 of file swaption.hpp.

◆ settlementMethod_

Settlement::Method settlementMethod_

private

Definition at line 81 of file swaption.hpp.

Public Member Functions

Serialisation

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Swaption() [1/2]

◆ Swaption() [2/2]

Member Function Documentation

◆ build()

◆ optionData()

◆ legData()

◆ fromXML()

◆ toXML()

◆ notional()

◆ additionalData()

◆ hasCashflows()

◆ isExercised()

◆ underlyingIndices()

◆ buildUnderlyingSwaps()

Member Data Documentation

◆ optionData_

◆ legData_

◆ underlying_

◆ exerciseBuilder_

◆ positionType_

◆ exerciseType_

◆ settlementType_

◆ settlementMethod_