#include <ored/portfolio/commodityswap.hpp>

Inheritance diagram for CommoditySwap:

Collaboration diagram for CommoditySwap:

Public Member Functions
	CommoditySwap ()

	CommoditySwap (const ore::data::Envelope &env, const std::vector< ore::data::LegData > &legs)

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

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

std::map< ore::data::AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &referenceDataManager=nullptr) const override
	Add underlying Commodity names. More...

Inspectors
const std::vector< ore::data::LegData > &	legData () const

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

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

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

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

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

const RequiredFixings &	requiredFixings () const

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

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

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

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

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

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

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

const string &	id () const

const string &	tradeType () const

const Envelope &	envelope () const

const set< string > &	portfolioIds () const

const TradeActions &	tradeActions () const

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

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

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

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

const string &	npvCurrency () const

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

virtual bool	hasCashflows () const

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

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

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

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

void	fromFile (const std::string &filename)

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

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

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

Serialisation
std::vector< ore::data::LegData >	legData_

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

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

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

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

void	check () const

void	buildLeg (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &ef, const ore::data::LegData &legDatum, const std::string &configuration)

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 38 of file commodityswap.hpp.

Constructor & Destructor Documentation

◆ CommoditySwap() [1/2]

CommoditySwap ( )

Definition at line 40 of file commodityswap.hpp.

40: ore::data::Trade("CommoditySwap") {}

ore::data::Trade

Trade base class.

Definition: trade.hpp:55

◆ CommoditySwap() [2/2]

CommoditySwap	(	const ore::data::Envelope &	env,
		const std::vector< ore::data::LegData > &	legs
	)

Definition at line 42 of file commodityswap.hpp.

43 : Trade("CommoditySwap", env), legData_(legs) {}

ore::data::CommoditySwap::legData_

std::vector< ore::data::LegData > legData_

Definition: commodityswap.hpp:75

ore::data::Trade::legs

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

Definition: trade.hpp:143

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

Member Function Documentation

◆ build()

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

override

Definition at line 43 of file commodityswap.cpp.

                                                                                   {
 
    reset();
 
    LOG("CommoditySwap::build() called for trade " << id());
 
    // ISDA taxonomy, assuming Commodity follows the Equity template
    additionalData_["isdaAssetClass"] = string("Commodity");
    additionalData_["isdaBaseProduct"] = string("Swap");
    additionalData_["isdaSubProduct"] = string("Price Return Basic Performance");
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = string("");  
 
    check();
 
    // Arbitrarily choose NPV currency from 1st leg. Already checked that both leg currencies equal.
    npvCurrency_ = legData_[0].currency();
 
    // Set notional to N/A for now, but reset this for a commodity fixed respectively floating leg below.
    notional_ = Null<Real>();
    notionalCurrency_ = legData_[0].currency();
 
    const QuantLib::ext::shared_ptr<Market> market = engineFactory->market();
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("CommoditySwap");
    QuantLib::ext::shared_ptr<CommoditySwapEngineBuilder> engineBuilder =
        QuantLib::ext::dynamic_pointer_cast<CommoditySwapEngineBuilder>(builder);
    const string& configuration = builder->configuration(MarketContext::pricing);
 
    // Build the commodity swap legs
    
    // Build the floating legs first in case we need the quantities to build the fixed legs.
    // Store the floating legs in the map with their "Tag" as key. This allows the fixed leg to find the floating leg 
    // with the matching "Tag" when retrieving the quantities if it needs them. Note the if all the tags are empty, 
    // the map entry gets overwritten and the fixed leg with empty tag matches a random floating leg with empty tag. 
    // This is by design i.e. use tags if you want to link specific legs.
    map<string, Leg> floatingLegs;
    vector<Size> legsIdx;
    for (Size t = 0; t < legData_.size(); t++) {
        const auto& legDatum = legData_.at(t);
 
        const string& type = legDatum.legType();
        if (type == "CommodityFixed")
            continue;
 
        // Build the leg and add it to legs_
        buildLeg(engineFactory, legDatum, configuration);
        legsIdx.push_back(t);
 
        // Only add to map if CommodityFloatingLegData
        if (auto cfld = QuantLib::ext::dynamic_pointer_cast<CommodityFloatingLegData>(legDatum.concreteLegData())) {
            floatingLegs[cfld->tag()] = legs_.back();
        }
    }
 
    // Build any fixed legs skipped above.
    for (Size t = 0; t < legData_.size();  t++) {
        const auto& legDatum = legData_.at(t);
 
        // take a copy, since we might modify the leg datum below
        auto effLegDatum = legDatum;
 
        const string& type = effLegDatum.legType();
        if (type != "CommodityFixed")
            continue;
 
        // Update the commodity fixed leg quantities if necessary.
        auto cfld = QuantLib::ext::dynamic_pointer_cast<CommodityFixedLegData>(effLegDatum.concreteLegData());
        QL_REQUIRE(cfld, "CommodityFixed leg should have valid CommodityFixedLegData");
        if (cfld->quantities().empty()) {
 
            auto it = floatingLegs.find(cfld->tag());
            QL_REQUIRE(it != floatingLegs.end(), "Did not find a commodity floating leg corresponding to the" <<
                " fixed leg with tag '" << cfld->tag() << "' from which to take the quantities.");
 
            const Leg& leg = it->second;
            vector<Real> quantities;
            quantities.reserve(leg.size());
            for (const auto& cf : leg) {
                // If more options arise here, may think of visitor to get the commodity notional.
                auto ucf = unpackIndexWrappedCashFlow(cf);
                if (auto cicf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(ucf)) {
                    quantities.push_back(cicf->periodQuantity());
                } else if (auto ciacf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(ucf)) {
                    quantities.push_back(ciacf->periodQuantity());
                } else {
                    QL_FAIL("Expected a commodity indexed cashflow while building commodity fixed" <<
                        " leg quantities for trade " << id() << ".");
                }
            }
 
            cfld->setQuantities(quantities);
        }
        // overwrite payment dates if pay relative to future expiry of floating leg is specified
        if (effLegDatum.paymentDates().empty() &&
            cfld->commodityPayRelativeTo() == CommodityPayRelativeTo::FutureExpiryDate) {
            auto it = floatingLegs.find(cfld->tag());
            QL_REQUIRE(it != floatingLegs.end(),
                       "Did not find a commodity floating leg correpsonding to the fixed leg with tag '"
                           << cfld->tag() << "' from which to take the payment dates.");
            vector<string> tmp;
            for(auto const& cf: it->second) {
                tmp.push_back(ore::data::to_string(cf->date()));
            }
            effLegDatum.paymentDates() = tmp;
        }
 
        // Build the leg and add it to legs_
        buildLeg(engineFactory, effLegDatum, configuration);
        legsIdx.push_back(t);
    }
 
    // Reposition the leg-based data to match the original order according to legData_
    vector<Leg> legsTmp;
    vector<bool> legPayersTmp;
    vector<string> legCurrenciesTmp;
    for (const Size idx : legsIdx) {
        legsTmp.push_back(legs_.at(idx));
        legPayersTmp.push_back(legPayers_.at(idx));
        legCurrenciesTmp.push_back(legCurrencies_.at(idx));
    }
    legs_ = legsTmp;
    legPayers_ = legPayersTmp;
    legCurrencies_ = legCurrenciesTmp;
 
    // Create the QuantLib swap instrument and assign pricing engine
    auto swap = QuantLib::ext::make_shared<QuantLib::Swap>(legs_, legPayers_);
    QuantLib::ext::shared_ptr<PricingEngine> engine = engineBuilder->engine(parseCurrency(npvCurrency_));
    swap->setPricingEngine(engine);
    setSensitivityTemplate(*engineBuilder);
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(swap);
}

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 290 of file commodityswap.cpp.

                                           {
    Date asof = Settings::instance().evaluationDate();
    Real currentAmount = Null<Real>();
    // Get maximum current cash flow amount (quantity * strike, quantity * spot/forward price) across legs
    // include gearings and spreads; note that the swap is in a single currency.
    for (Size i = 0; i < legs_.size(); ++i) {
        for (Size j = 0; j < legs_[i].size(); ++j) {
            QuantLib::ext::shared_ptr<CashFlow> flow = legs_[i][j];
            // pick flow with earliest payment date on this leg
            if (flow->date() > asof) {
                if (currentAmount == Null<Real>())
                    currentAmount = flow->amount();
                else // set on a previous leg already, set to maximum
                    currentAmount = std::max(currentAmount, flow->amount());
                break; // move on to the next leg
            }
        }
    }
 
    if (currentAmount != Null<Real>()) {
        return currentAmount;
    } else {
        ALOG("Error retrieving current notional for commodity swap " << id() << " as of " << io::iso_date(asof));
        return Null<Real>();
    }
}

◆ underlyingIndices()

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

override

Add underlying Commodity names.

Definition at line 318 of file commodityswap.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:

◆ legData()

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

Definition at line 54 of file commodityswap.hpp.

54{ return legData_; }

◆ fromXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 335 of file commodityswap.cpp.

                                         {
    DLOG("CommoditySwap::fromXML called");
    Trade::fromXML(node);
    legData_.clear();
 
    XMLNode* swapNode = XMLUtils::getChildNode(node, "SwapData");
    QL_REQUIRE(swapNode, "No SwapData Node");
 
    vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(swapNode, "LegData");
    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 351 of file commodityswap.cpp.

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

Here is the call graph for this function:

Here is the caller 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 175 of file commodityswap.cpp.

                                                                      {
    Size numLegs = legData_.size();
    // use the build time as of date to determine current notionals
    Date asof = Settings::instance().evaluationDate();
    QuantLib::ext::shared_ptr<QuantLib::Swap> swap = QuantLib::ext::dynamic_pointer_cast<QuantLib::Swap>(instrument_->qlInstrument());
    for (Size i = 0; i < numLegs; ++i) {
        string legID = to_string(i+1);
        additionalData_["legType[" + legID + "]"] = legData_[i].legType();
        additionalData_["isPayer[" + legID + "]"] = legData_[i].isPayer();
        additionalData_["currency[" + legID + "]"] = legData_[i].currency();
        if (swap)
            additionalData_["legNPV[" + legID + "]"] = swap->legNPV(i);
        else
            ALOG("commodity swap underlying instrument not set, skip leg npv reporting");
        for (Size j = 0; j < legs_[i].size(); ++j) {
            QuantLib::ext::shared_ptr<CashFlow> flow = legs_[i][j];
            if (flow->date() > asof) {
                std::string label = legID + ":" + std::to_string(j + 1);
                // CommodityFloatingLeg consists of indexed or indexed average cash flows
                QuantLib::ext::shared_ptr<CommodityIndexedCashFlow> indexedFlow =
                    QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(unpackIndexWrappedCashFlow(flow));
                if (indexedFlow) {
                    additionalData_["quantity[" + label + "]"] = indexedFlow->quantity();
                    additionalData_["periodQuantity[" + label + "]"] = indexedFlow->periodQuantity();
                    additionalData_["gearing[" + label + "]"] = indexedFlow->gearing();
                    if (indexedFlow->isAveragingFrontMonthCashflow(asof)) {
                        std::vector<Real> priceVec;
                        std::vector<std::string> indexVec;
                        std::vector<Date> indexExpiryVec, pricingDateVec;
                        double averagePrice = 0;
                        for (const auto& pd : indexedFlow->spotAveragingPricingDates()) {
                            if (pd > asof) {
                                auto index = indexedFlow->index();
                                auto pricingDate = indexedFlow->lastPricingDate();
                                indexVec.push_back(index->name());
                                indexExpiryVec.push_back(index->expiryDate());
                                pricingDateVec.push_back(pd);
                                priceVec.push_back(index->fixing(pricingDate));
                                averagePrice += priceVec.back();
                            }
                            else {
                                auto index = indexedFlow->spotIndex();
                                indexVec.push_back(index->name());
                                indexExpiryVec.push_back(index->expiryDate());
                                pricingDateVec.push_back(pd);
                                priceVec.push_back(index->fixing(pd));
                                averagePrice += priceVec.back();
                            }
                        }
                        averagePrice /= indexedFlow->spotAveragingPricingDates().size();
                        additionalData_["index[" + label + "]"] = indexVec;
                        additionalData_["indexExpiry[" + label + "]"] = indexExpiryVec;
                        additionalData_["price[" + label + "]"] = priceVec;
                        additionalData_["averagePrice[" + label + "]"] = averagePrice;
                        additionalData_["pricingDate[" + label + "]"] = pricingDateVec;
                    }
                    else {
                    additionalData_["index[" + label + "]"] = indexedFlow->index()->name();
                    additionalData_["indexExpiry[" + label + "]"] = indexedFlow->index()->expiryDate();
                    additionalData_["price[" + label + "]"] = indexedFlow->index()->fixing(indexedFlow->pricingDate());
                    additionalData_["pricingDate[" + label + "]"] = to_string(indexedFlow->pricingDate());
                    }
                    additionalData_["paymentDate[" + label + "]"] = to_string(indexedFlow->date());
                }
                QuantLib::ext::shared_ptr<CommodityIndexedAverageCashFlow> indexedAvgFlow =
                    QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(unpackIndexWrappedCashFlow(flow));
                if (indexedAvgFlow) {
                    additionalData_["quantity[" + label + "]"] = indexedAvgFlow->quantity();
                    additionalData_["periodQuantity[" + label + "]"] = indexedAvgFlow->periodQuantity();
                    additionalData_["gearing[" + label + "]"] = indexedAvgFlow->gearing();
                    std::vector<Real> priceVec;
                    std::vector<std::string> indexVec;
                    std::vector<Date> indexExpiryVec, pricingDateVec;
                    double averagePrice = 0;
                    for (const auto& kv : indexedAvgFlow->indices()) {
                        indexVec.push_back(kv.second->name());
                        indexExpiryVec.push_back(kv.second->expiryDate());
                        pricingDateVec.push_back(kv.first);
                        priceVec.push_back(kv.second->fixing(kv.first));
                        averagePrice += priceVec.back();
                    }
                    averagePrice /= indexedAvgFlow->indices().size();
                    additionalData_["index[" + label + "]"] = indexVec;
                    additionalData_["indexExpiry[" + label + "]"] = indexExpiryVec;
                    additionalData_["price[" + label + "]"] = priceVec;
                    additionalData_["averagePrice[" + label + "]"] = averagePrice;
                    additionalData_["pricingDate[" + label + "]"] = pricingDateVec;
                    additionalData_["paymentDate[" + label + "]"] = to_string(indexedAvgFlow->date());
                }
                // CommodityFixedLeg consists of simple cash flows
                Real flowAmount = 0.0;
                try {
                    flowAmount = flow->amount();
                } catch (std::exception& e) {
                    ALOG("flow amount could not be determined for trade " << id() << ", set to zero: " << e.what());
                }
                additionalData_["amount[" + label + "]"] = flowAmount;
                additionalData_["paymentDate[" + label + "]"] = to_string(flow->date());
            }
        }
        if (legs_[i].size() > 0) {
            QuantLib::ext::shared_ptr<Coupon> coupon = QuantLib::ext::dynamic_pointer_cast<Coupon>(legs_[i][0]);
            if (coupon) {
                Real originalNotional = 0.0;
                try { originalNotional = coupon->nominal(); }
                catch(std::exception& e) {
                    ALOG("original nominal could not be determined for trade " << id() << ", set to zero: " << e.what());
                }
                additionalData_["originalNotional[" + legID + "]"] = originalNotional;
            }
        }
    }
    return additionalData_;
}

Here is the call graph for this function:

◆ createLegData()

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

private

Definition at line 66 of file commodityswap.hpp.

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

Here is the caller graph for this function:

◆ check()

void check ( ) const

private

Definition at line 360 of file commodityswap.cpp.

                                {
    QL_REQUIRE(legData_.size() >= 2, "Expected at least two commodity legs but found " << legData_.size());
    auto ccy = legData_[0].currency();
    for (const auto& legDatum : legData_) {
        QL_REQUIRE(legDatum.currency() == ccy, "Cross currency commodity swaps are not supported");
    }
}

Here is the caller graph for this function:

◆ buildLeg()

void buildLeg	(	const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &	ef,
		const ore::data::LegData &	legDatum,
		const std::string &	configuration
	)

private

Definition at line 368 of file commodityswap.cpp.

                                                          {
 
    auto legBuilder = ef->legBuilder(legDatum.legType());
    Leg leg = legBuilder->buildLeg(legDatum, ef, requiredFixings_, configuration);
    legs_.push_back(leg);
    legPayers_.push_back(legDatum.isPayer());
    legCurrencies_.push_back(legDatum.currency());
 
    // Update maturity
    maturity_ = max(CashFlows::maturityDate(leg), maturity_);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ legData_

std::vector<ore::data::LegData> legData_

private

Definition at line 75 of file commodityswap.hpp.

Public Member Functions

Serialisation

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CommoditySwap() [1/2]

◆ CommoditySwap() [2/2]

Member Function Documentation

◆ build()

◆ notional()

◆ underlyingIndices()

◆ legData()

◆ fromXML()

◆ toXML()

◆ additionalData()

◆ createLegData()

◆ check()

◆ buildLeg()

Member Data Documentation

◆ legData_