CommoditySwaption Class Reference

#include <ored/portfolio/commodityswaption.hpp>

Inheritance diagram for CommoditySwaption:

Collaboration diagram for CommoditySwaption:

Public Member Functions
	CommoditySwaption ()
	CommoditySwaption (const ore::data::Envelope &env, const ore::data::OptionData &option, const std::vector< ore::data::LegData > &legData)
void	build (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory) override
QuantLib::Real	notional () const override
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...
std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const override
	Add underlying Commodity names. More...
Inspectors
const ore::data::OptionData &	option ()
const std::vector< ore::data::LegData > &	legData () const
Serialisation
virtual void	fromXML (ore::data::XMLNode *node) override
virtual 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...
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...

Trade
ore::data::OptionData	option_
vector< ore::data::LegData >	legData_
QuantLib::ext::shared_ptr< QuantLib::Exercise >	exercise_
std::string	name_
std::string	ccy_
QuantLib::Date	startDate_
QuantLib::ext::shared_ptr< CommoditySwap >	commoditySwap_
bool	hasCashflows () const override
QuantLib::ext::shared_ptr< ore::data::LegData >	createLegData () const
QuantLib::ext::shared_ptr< QuantLib::Swap >	buildSwap (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory)

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 Commodity Swap

Definition at line 35 of file commodityswaption.hpp.

Constructor & Destructor Documentation

CommoditySwaption() [1/2]

CommoditySwaption

(

)

Definition at line 37 of file commodityswaption.hpp.

: ore::data::Trade("CommoditySwaption") {}

CommoditySwaption() [2/2]

CommoditySwaption	(	const ore::data::Envelope &	env,
		const ore::data::OptionData &	option,
		const std::vector< ore::data::LegData > &	legData
	)

Definition at line 39 of file commodityswaption.hpp.

        : Trade("CommoditySwaption", env), legData_(legData) {}

Member Function Documentation

build()

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

override

Definition at line 44 of file commodityswaption.cpp.

                                                                                       {
 
    reset();
 
    DLOG("CommoditySwaption::build() called for trade " << id());
 
    // ISDA taxonomy
    additionalData_["isdaAssetClass"] = std::string("Commodity");
    additionalData_["isdaBaseProduct"] = std::string("Other");
    additionalData_["isdaSubProduct"] = std::string("");
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = std::string("");
 
    // Swaption details
    Settlement::Type settleType = parseSettlementType(option_.settlement());
 
    // Just set a consistent method here if it is left empty
    Settlement::Method settleMethod = Settlement::PhysicalOTC;
    if (option_.settlementMethod().empty()) {
        if (settleType == Settlement::Cash) {
            settleMethod = Settlement::CollateralizedCashPrice;
        }
    } else {
        settleMethod = parseSettlementMethod(option_.settlementMethod());
    }
 
    QL_REQUIRE(option_.exerciseDates().size() == 1, "Commodity swaption must be European");
    Date exDate = parseDate(option_.exerciseDates().front());
    QL_REQUIRE(exDate >= Settings::instance().evaluationDate(),
               "Exercise date, " << io::iso_date(exDate) << ", should be in the future relative to the valuation date "
                                 << io::iso_date(Settings::instance().evaluationDate()));
 
    // Build the underyling swap and check exercise date
    QuantLib::ext::shared_ptr<QuantLib::Swap> swap = buildSwap(engineFactory);
    QL_REQUIRE(exDate <= startDate_, "Expected the expiry date, " << io::iso_date(exDate)
                                                                  << " to be on or before the swap start date "
                                                                  << io::iso_date(startDate_));
 
    // Build the swaption
    exercise_ = QuantLib::ext::make_shared<EuropeanExercise>(exDate);
    QuantLib::ext::shared_ptr<QuantExt::GenericSwaption> swaption =
        QuantLib::ext::make_shared<QuantExt::GenericSwaption>(swap, exercise_, settleType, settleMethod);
 
    // Set the swaption's pricing engine
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(tradeType_);
    QuantLib::ext::shared_ptr<CommoditySwaptionEngineBuilder> engineBuilder =
        QuantLib::ext::dynamic_pointer_cast<CommoditySwaptionEngineBuilder>(builder);
    auto configuration = builder->configuration(MarketContext::pricing);
    Currency currency = parseCurrency(ccy_);
    QuantLib::ext::shared_ptr<PricingEngine> engine = engineBuilder->engine(currency, name_);
    setSensitivityTemplate(*engineBuilder);
    swaption->setPricingEngine(engine);
 
    // Set the instrument wrapper properly
    Position::Type positionType = parsePositionType(option_.longShort());
    if (settleType == Settlement::Cash) {
        Real multiplier = positionType == Position::Long ? 1.0 : -1.0;
        instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(swaption, multiplier);
    } else {
        instrument_ = QuantLib::ext::make_shared<EuropeanOptionWrapper>(swaption, positionType == Position::Long, exDate,
                                                                settleType == Settlement::Physical, swap);
    }
    // use underlying maturity independent of settlement type, following ISDA GRID/AANA guidance
    maturity_ = swap->maturityDate();
}

Here is the call 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 110 of file commodityswaption.cpp.

                                               {
    return commoditySwap_->notional();
}

underlyingIndices()

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

overridevirtual

Add underlying Commodity names.

Reimplemented from Trade.

Definition at line 159 of file commodityswaption.cpp.

                                                                                                                  {
 
    std::map<AssetClass, std::set<std::string>> result;
 
    for (auto ld : legData_) {
        set<string> indices = ld.indices();
        for (auto ind : indices) {
            QuantLib::ext::shared_ptr<Index> index = parseIndex(ind);
            // only handle commodity
            if (auto ci = QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityIndex>(index)) {
                result[AssetClass::COM].insert(ci->name());
            }
        }
    }
    return result;
}

Here is the call graph for this function:

option()

const ore::data::OptionData & option

(

)

Definition at line 52 of file commodityswaption.hpp.

{ return option_; }

legData()

const std::vector< ore::data::LegData > & legData

(

)

const

Definition at line 53 of file commodityswaption.hpp.

{ return legData_; }

fromXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 176 of file commodityswaption.cpp.

                                             {
 
    Trade::fromXML(node);
 
    XMLNode* swapNode = XMLUtils::getChildNode(node, "CommoditySwaptionData");
    QL_REQUIRE(swapNode, "No CommoditySwaptionData node");
 
    // Get the option data
    option_.fromXML(XMLUtils::getChildNode(swapNode, "OptionData"));
 
    // Get the leg data i.e. the leg data describing the underlying swap
    vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(swapNode, "LegData");
    QL_REQUIRE(nodes.size() == 2, "Two commodity swap legs expected, found " << nodes.size());
    legData_.clear();
    for (Size i = 0; i < nodes.size(); i++) {
        auto ld = createLegData();
        ld->fromXML(nodes[i]);
        legData_.push_back(*ld);
    }
}

Here is the call graph for this function:

toXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 197 of file commodityswaption.cpp.

                                                        {
    XMLNode* node = Trade::toXML(doc);
 
    // Add the root CommoditySwaptionData node
    XMLNode* swaptionNode = doc.allocNode("CommoditySwaptionData");
    XMLUtils::appendNode(node, swaptionNode);
 
    // Add the OptionData node
    XMLUtils::appendNode(swaptionNode, option_.toXML(doc));
 
    // Add the LegData nodes
    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:

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 64 of file commodityswaption.hpp.

{ return false; }

createLegData()

QuantLib::ext::shared_ptr< ore::data::LegData > createLegData ( ) const

private

Definition at line 68 of file commodityswaption.hpp.

{ return QuantLib::ext::make_shared<ore::data::LegData>(); }

Here is the caller graph for this function:

buildSwap()

QuantLib::ext::shared_ptr< QuantLib::Swap > buildSwap ( const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &  engineFactory )

private

Definition at line 114 of file commodityswaption.cpp.

                                                                                                                          {
 
    // Some checks to make sure the underlying swap is supported
    QL_REQUIRE(legData_.size() == 2, "Expected two commodity legs but found " << legData_.size());
    QL_REQUIRE(legData_[0].currency() == legData_[1].currency(), "Cross currency commodity swap not supported");
    QL_REQUIRE(legData_[0].isPayer() != legData_[1].isPayer(),
               "Both commodity legs are " << (legData_[0].isPayer() ? "paying" : "receiving"));
 
    QL_REQUIRE(legData_[0].legType() == "CommodityFixed" || legData_[0].legType() == "CommodityFloating",
               "Leg type needs to be CommodityFixed or CommodityFloating but 1st leg has type "
                   << legData_[0].legType());
    QL_REQUIRE(legData_[1].legType() == "CommodityFixed" || legData_[1].legType() == "CommodityFloating",
               "Leg type needs to be CommodityFixed or CommodityFloating but 2nd leg has type "
                   << legData_[1].legType());
 
    if (legData_[0].legType() == "CommodityFixed") {
        QL_REQUIRE(legData_[1].legType() == "CommodityFloating",
                   "1st leg is CommodityFixed so 2nd leg should be CommodityFloating but is " << legData_[1].legType());
        auto floatLeg = QuantLib::ext::dynamic_pointer_cast<CommodityFloatingLegData>(legData_[1].concreteLegData());
        name_ = floatLeg->name();
    } else {
        auto floatLeg = QuantLib::ext::dynamic_pointer_cast<CommodityFloatingLegData>(legData_[0].concreteLegData());
    QL_REQUIRE(floatLeg, "first leg has type " << legData_[0].legType() << ", expected CommodityFloating");
        name_ = floatLeg->name();
    }
 
    // Build the underlying commodity swap
    commoditySwap_ = QuantLib::ext::make_shared<CommoditySwap>(envelope(), legData_);
    commoditySwap_->build(engineFactory);
 
    // Get the QuantLib::Swap from the commodity swap
    auto qlInstrument = commoditySwap_->instrument()->qlInstrument();
    QuantLib::ext::shared_ptr<QuantLib::Swap> swap = QuantLib::ext::dynamic_pointer_cast<QuantLib::Swap>(qlInstrument);
    QL_REQUIRE(swap, "Expected an underlying swap instrument from CommoditySwap");
 
    // Populate relevant member variables, notonal and notional currency are set by the underlying Swap build already.
    startDate_ = swap->startDate();
    ccy_ = npvCurrency_ = legData_[0].currency();
    notional_ = Null<Real>();
    notionalCurrency_ = commoditySwap_->notionalCurrency();
 
    return swap;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

option_

ore::data::OptionData option_

private

Definition at line 72 of file commodityswaption.hpp.

legData_

vector<ore::data::LegData> legData_

private

Definition at line 73 of file commodityswaption.hpp.

exercise_

QuantLib::ext::shared_ptr<QuantLib::Exercise> exercise_

private

Definition at line 74 of file commodityswaption.hpp.

name_

std::string name_

private

Definition at line 75 of file commodityswaption.hpp.

ccy_

std::string ccy_

private

Definition at line 76 of file commodityswaption.hpp.

startDate_

QuantLib::Date startDate_

private

Definition at line 77 of file commodityswaption.hpp.

commoditySwap_

QuantLib::ext::shared_ptr<CommoditySwap> commoditySwap_

private

Definition at line 78 of file commodityswaption.hpp.