#include <ored/portfolio/commodityoptionstrip.hpp>

Inheritance diagram for CommodityOptionStrip:

Collaboration diagram for CommodityOptionStrip:

Public Member Functions
	CommodityOptionStrip ()

	CommodityOptionStrip (const ore::data::Envelope &envelope, const ore::data::LegData &legData, const std::vector< QuantLib::Position::Type > &callPositions, const std::vector< QuantLib::Real > &callStrikes, const std::vector< QuantLib::Position::Type > &putPositions, const std::vector< QuantLib::Real > &putStrikes, QuantLib::Real premium=0.0, const std::string &premiumCurrency="", const QuantLib::Date &premiumPayDate=QuantLib::Date(), const std::string &style="", const std::string &settlement="", const BarrierData &callBarrierData={}, const BarrierData &putBarrierData={}, const std::string &fxIndex="", const bool isDigital=false, Real payoffPerUnit=0.0)

void	build (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory) override
	Implement the build method. More...

std::map< ore::data::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::LegData &	legData () const

const std::vector< QuantLib::Position::Type > &	callPositions () const

const std::vector< QuantLib::Real > &	callStrikes () const

const std::vector< QuantLib::Position::Type > &	putPositions () const

const std::vector< QuantLib::Real > &	putStrikes () const

const PremiumData &	premiumDate () const

const std::string &	style () const

const std::string &	settlement () const

const std::string &	fxIndex () const

const BarrierData &	callBarrierData () const

const BarrierData &	putBarrierData () const

const bool	isDigital () const

const Real	payoffPerUnit () 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 QuantLib::Real	notional () const
	Return the current notional in npvCurrency. See individual sub-classes for the precise definition. More...

virtual string	notionalCurrency () const

const Date &	maturity () const

virtual bool	isExpired (const Date &d)

const string &	issuer () const

template<typename T >
T	additionalDatum (const std::string &tag) const
	returns any additional datum. More...

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

const std::string &	sensitivityTemplate () const

void	validate () const
	Utility to validate that everything that needs to be set in this base class is actually set. More...

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::LegData	legData_

std::vector< QuantLib::Position::Type >	callPositions_

std::vector< QuantLib::Real >	callStrikes_

std::vector< QuantLib::Position::Type >	putPositions_

std::vector< QuantLib::Real >	putStrikes_

PremiumData	premiumData_

std::string	style_

std::string	settlement_

BarrierData	callBarrierData_

BarrierData	putBarrierData_

std::string	fxIndex_

bool	isDigital_

Real	unaryPayoff_

QuantLib::ext::shared_ptr< CommodityFloatingLegData >	commLegData_

bool	hasCashflows () const override

void	buildAPOs (const QuantLib::Leg &leg, const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory)
	Build an average price option strip. More...

void	buildStandardOptions (const QuantLib::Leg &leg, const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory)
	Build a standard option strip. More...

void	check (QuantLib::Size numberPeriods) const
	Perform checks before building. 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 Commodity option strip

Definition at line 38 of file commodityoptionstrip.hpp.

Constructor & Destructor Documentation

◆ CommodityOptionStrip() [1/2]

CommodityOptionStrip ( )

Definition at line 40 of file commodityoptionstrip.hpp.

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

ore::data::Trade

Trade base class.

Definition: trade.hpp:55

◆ CommodityOptionStrip() [2/2]

CommodityOptionStrip	(	const ore::data::Envelope &	envelope,
		const ore::data::LegData &	legData,
		const std::vector< QuantLib::Position::Type > &	callPositions,
		const std::vector< QuantLib::Real > &	callStrikes,
		const std::vector< QuantLib::Position::Type > &	putPositions,
		const std::vector< QuantLib::Real > &	putStrikes,
		QuantLib::Real	premium = `0.0`,
		const std::string &	premiumCurrency = `""`,
		const QuantLib::Date &	premiumPayDate = `QuantLib::Date()`,
		const std::string &	style = `""`,
		const std::string &	settlement = `""`,
		const BarrierData &	callBarrierData = `{}`,
		const BarrierData &	putBarrierData = `{}`,
		const std::string &	fxIndex = `""`,
		const bool	isDigital = `false`,
		Real	payoffPerUnit = `0.0`
	)

Member Function Documentation

◆ build()

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

override

Implement the build method.

Definition at line 84 of file commodityoptionstrip.cpp.

                                                                                          {
 
    reset();
 
    DLOG("CommodityOptionStrip::build() called for trade " << id());
 
    // ISDA taxonomy, assuming Commodity follows the Equity template
    additionalData_["isdaAssetClass"] = std::string("Commodity");
    additionalData_["isdaBaseProduct"] = std::string("Option");
    additionalData_["isdaSubProduct"] = std::string("Price Return Basic Performance");
    // skip the transaction level mapping for now
    additionalData_["isdaTransaction"] = std::string();
 
    npvCurrency_ = notionalCurrency_ = legData_.currency();
 
    // Check that the leg data is of type CommodityFloating
    auto conLegData = legData_.concreteLegData();
    commLegData_ = QuantLib::ext::dynamic_pointer_cast<CommodityFloatingLegData>(conLegData);
    QL_REQUIRE(commLegData_, "CommodityOptionStrip leg data should be of type CommodityFloating");
    if(!commLegData_->fxIndex().empty())
        fxIndex_= commLegData_->fxIndex();
    // Build the commodity floating leg data
    auto legBuilder = engineFactory->legBuilder(legData_.legType());
    auto cflb = QuantLib::ext::dynamic_pointer_cast<CommodityFloatingLegBuilder>(legBuilder);
    QL_REQUIRE(cflb, "Expected a CommodityFloatingLegBuilder for leg type " << legData_.legType());
    Leg leg =
        cflb->buildLeg(legData_, engineFactory, requiredFixings_, engineFactory->configuration(MarketContext::pricing));
 
    // Perform checks
    check(leg.size());
 
    // We update the notional_ in either buildAPOs or buildStandardOptions below.
    notional_ = Null<Real>();
 
    // Build the strip of option trades
    legData_.concreteLegData();
 
    if (commLegData_->isAveraged() && !cflb->allAveraging()) {
        buildAPOs(leg, engineFactory);
    } else {
        buildStandardOptions(leg, engineFactory);
    }
 
    // Add leg to legs_ so that fixings method can work.
    legs_.push_back(leg);
    legPayers_.push_back(false);
    legCurrencies_.push_back(npvCurrency_);
}

Here is the call graph for this function:

◆ underlyingIndices()

std::map< ore::data::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 134 of file commodityoptionstrip.cpp.

                                                                                                                     {
    std::map<ore::data::AssetClass, std::set<std::string>> result;
 
    set<string> indices = legData_.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[ore::data::AssetClass::COM].insert(ci->name());
        }
    }
    return result;
}

Here is the call graph for this function:

◆ legData()

const ore::data::LegData & legData ( ) const

Definition at line 64 of file commodityoptionstrip.hpp.

64{ return legData_; }

◆ callPositions()

const std::vector< QuantLib::Position::Type > & callPositions ( ) const

Definition at line 65 of file commodityoptionstrip.hpp.

65{ return callPositions_; }

ore::data::CommodityOptionStrip::callPositions_

std::vector< QuantLib::Position::Type > callPositions_

Definition: commodityoptionstrip.hpp:92

◆ callStrikes()

const std::vector< QuantLib::Real > & callStrikes ( ) const

Definition at line 66 of file commodityoptionstrip.hpp.

66{ return callStrikes_; }

ore::data::CommodityOptionStrip::callStrikes_

std::vector< QuantLib::Real > callStrikes_

Definition: commodityoptionstrip.hpp:93

◆ putPositions()

const std::vector< QuantLib::Position::Type > & putPositions ( ) const

Definition at line 67 of file commodityoptionstrip.hpp.

67{ return putPositions_; }

ore::data::CommodityOptionStrip::putPositions_

std::vector< QuantLib::Position::Type > putPositions_

Definition: commodityoptionstrip.hpp:94

◆ putStrikes()

const std::vector< QuantLib::Real > & putStrikes ( ) const

Definition at line 68 of file commodityoptionstrip.hpp.

68{ return putStrikes_; }

ore::data::CommodityOptionStrip::putStrikes_

std::vector< QuantLib::Real > putStrikes_

Definition: commodityoptionstrip.hpp:95

◆ premiumDate()

const PremiumData & premiumDate ( ) const

Definition at line 69 of file commodityoptionstrip.hpp.

69{ return premiumData_; }

ore::data::CommodityOptionStrip::premiumData_

PremiumData premiumData_

Definition: commodityoptionstrip.hpp:96

◆ style()

const std::string & style ( ) const

Definition at line 70 of file commodityoptionstrip.hpp.

70{ return style_; }

ore::data::CommodityOptionStrip::style_

std::string style_

Definition: commodityoptionstrip.hpp:97

Here is the caller graph for this function:

◆ settlement()

const std::string & settlement ( ) const

Definition at line 71 of file commodityoptionstrip.hpp.

71{ return settlement_; }

ore::data::CommodityOptionStrip::settlement_

std::string settlement_

Definition: commodityoptionstrip.hpp:98

Here is the caller graph for this function:

◆ fxIndex()

const std::string & fxIndex ( ) const

Definition at line 72 of file commodityoptionstrip.hpp.

72{ return fxIndex_; }

◆ callBarrierData()

const BarrierData & callBarrierData ( ) const

Definition at line 73 of file commodityoptionstrip.hpp.

73{ return callBarrierData_; }

ore::data::CommodityOptionStrip::callBarrierData_

BarrierData callBarrierData_

Definition: commodityoptionstrip.hpp:99

◆ putBarrierData()

const BarrierData & putBarrierData ( ) const

Definition at line 74 of file commodityoptionstrip.hpp.

74{ return putBarrierData_; }

ore::data::CommodityOptionStrip::putBarrierData_

BarrierData putBarrierData_

Definition: commodityoptionstrip.hpp:100

◆ isDigital()

const bool isDigital ( ) const

Definition at line 75 of file commodityoptionstrip.hpp.

75{ return isDigital_; }

ore::data::CommodityOptionStrip::isDigital_

bool isDigital_

Definition: commodityoptionstrip.hpp:102

Here is the caller graph for this function:

◆ payoffPerUnit()

const Real payoffPerUnit ( ) const

Definition at line 76 of file commodityoptionstrip.hpp.

76{ return unaryPayoff_; }

ore::data::CommodityOptionStrip::unaryPayoff_

Real unaryPayoff_

Definition: commodityoptionstrip.hpp:103

Here is the caller graph for this function:

◆ fromXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 148 of file commodityoptionstrip.cpp.

                                                {
 
    Trade::fromXML(node);
 
    XMLNode* stripNode = XMLUtils::getChildNode(node, "CommodityOptionStripData");
    QL_REQUIRE(stripNode, "No CommodityOptionStripData Node");
 
    legData_.fromXML(XMLUtils::getChildNode(stripNode, "LegData"));
 
    if (XMLNode* n = XMLUtils::getChildNode(stripNode, "Calls")) {
        vector<string> ls = XMLUtils::getChildrenValues(n, "LongShorts", "LongShort", false);
        callPositions_ = parseVectorOfValues<Position::Type>(ls, &parsePositionType);
        callStrikes_ = XMLUtils::getChildrenValuesAsDoubles(n, "Strikes", "Strike", false);
        if (XMLNode* n2 = XMLUtils::getChildNode(n, "BarrierData")) {
            callBarrierData_.fromXML(n2);
        }
    }
 
    if (XMLNode* n = XMLUtils::getChildNode(stripNode, "Puts")) {
        vector<string> ls = XMLUtils::getChildrenValues(n, "LongShorts", "LongShort", false);
        putPositions_ = parseVectorOfValues<Position::Type>(ls, &parsePositionType);
        putStrikes_ = XMLUtils::getChildrenValuesAsDoubles(n, "Strikes", "Strike", false);
        if (XMLNode* n2 = XMLUtils::getChildNode(n, "BarrierData")) {
            putBarrierData_.fromXML(n2);
        }
    }
    premiumData_.fromXML(stripNode);
    style_ = "";
    if (XMLNode* n = XMLUtils::getChildNode(stripNode, "Style"))
        style_ = XMLUtils::getNodeValue(n);
 
    settlement_ = "";
    if (XMLNode* n = XMLUtils::getChildNode(stripNode, "Settlement"))
        settlement_ = XMLUtils::getNodeValue(n);
 
    isDigital_ = false;
    if (XMLNode* n = XMLUtils::getChildNode(stripNode, "IsDigital") )
        isDigital_ = parseBool(XMLUtils::getNodeValue(n));
    if (isDigital_) {
        XMLNode* n = XMLUtils::getChildNode(stripNode, "PayoffPerUnit");
        QL_REQUIRE(n, "A strip of commodity digital options requires PayoffPerUnit node");
        unaryPayoff_ = parseReal(XMLUtils::getNodeValue(n));
    }
}

Here is the call graph for this function:

◆ toXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 193 of file commodityoptionstrip.cpp.

                                                           {
 
    XMLNode* node = Trade::toXML(doc);
 
    XMLNode* stripNode = doc.allocNode("CommodityOptionStripData");
    XMLUtils::appendNode(node, stripNode);
 
    XMLUtils::appendNode(stripNode, legData_.toXML(doc));
 
    if (!callStrikes_.empty()) {
        XMLNode* callsNode = doc.allocNode("Calls");
        XMLUtils::addChildren(doc, callsNode, "LongShorts", "LongShort", strPositions(callPositions_));
        XMLUtils::addChildren(doc, callsNode, "Strikes", "Strike", callStrikes_);
        if (callBarrierData_.initialized()) {
            XMLUtils::appendNode(callsNode, callBarrierData_.toXML(doc));
        }
        XMLUtils::appendNode(stripNode, callsNode);
    }
 
    if (!putStrikes_.empty()) {
        XMLNode* putsNode = doc.allocNode("Puts");
        XMLUtils::addChildren(doc, putsNode, "LongShorts", "LongShort", strPositions(putPositions_));
        XMLUtils::addChildren(doc, putsNode, "Strikes", "Strike", putStrikes_);
        if (putBarrierData_.initialized()) {
            XMLUtils::appendNode(putsNode, putBarrierData_.toXML(doc));
        }
        XMLUtils::appendNode(stripNode, putsNode);
    }
 
    // These are all optional, really they should be grouped here
    if (!premiumData_.premiumData().empty())
        XMLUtils::appendNode(stripNode, premiumData_.toXML(doc));
 
    if (!style_.empty())
        XMLUtils::addChild(doc, stripNode, "Style", style_);
 
    if (!settlement_.empty())
        XMLUtils::addChild(doc, stripNode, "Settlement", settlement_);
 
    if (isDigital_){
        XMLUtils::addChild(doc, stripNode, "IsDigital", isDigital_);
        XMLUtils::addChild(doc, stripNode, "PayoffPerUnit", unaryPayoff_);
    }
    return node;
}

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 87 of file commodityoptionstrip.hpp.

87{ return false; }

◆ buildAPOs()

void buildAPOs	(	const QuantLib::Leg &	leg,
		const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &	engineFactory
	)

private

Build an average price option strip.

Definition at line 239 of file commodityoptionstrip.cpp.

                                                                                                              {
 
    // If style is set and not European, log a warning.
    if (!style_.empty() && style_ != "European") {
        WLOG("Style should be European when the commodity option strip is a strip of APOs. Ignoring style "
             << style_ << " and proceeding as if European.");
    }
 
    // If settlement is set and not Cash, log a warning. Physical settlement for APOs does not make sense.
    if (!settlement_.empty() && settlement_ != "Cash") {
        WLOG("Settlement should be Cash when the commodity option strip is a strip of APOs. Ignoring settlement "
             << settlement_ << " and proceeding as if Cash.");
    }
 
 
    // Populate these with the call/put options requested in each period
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
 
    for (Size i = 0; i < leg.size(); i++) {
        auto cf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(leg[i]);
        QL_REQUIRE(cf, "Expected a CommodityIndexedAverageCashFlow while building APO");
 
        // Populate call and/or put data at this leg period
        vector<TempOptionData> tempData;
        Date exerciseDate = cf->indices().rbegin()->first;
        vector<string> strExerciseDate = {to_string(exerciseDate)};
        maturity_ = maturity_ == Date() ? cf->date() : max(maturity_, cf->date());
        string stemId = id() + "_" + strExerciseDate[0] + "_";
        if (!callStrikes_.empty()) {
            Position::Type position = callPositions_.size() == 1 ? callPositions_[0] : callPositions_[i];
            Real strike = callStrikes_.size() == 1 ? callStrikes_[0] : callStrikes_[i];
            string id = stemId + "call";
            tempData.push_back({"Call", position, strike, id});
        }
        if (!putStrikes_.empty()) {
            Position::Type position = putPositions_.size() == 1 ? putPositions_[0] : putPositions_[i];
            Real strike = putStrikes_.size() == 1 ? putStrikes_[0] : putStrikes_[i];
            string id = stemId + "put";
            tempData.push_back({"Put", position, strike, id});
        }
 
        // Each CommodityAveragePriceOption is set up to go through the commodity floating leg builder which for
        // averaging cashflows includes the start date on the first coupon in the leg and includes the end date on
        // the last coupon in the leg. Only one coupon in each of the cases here so need to do this manually here.
        Date start = cf->indices().begin()->first;
 
        // Build a commodity APO for the call and/or put in this period
        
        for (const auto& tempDatum : tempData) {
            QuantLib::ext::shared_ptr<Trade> commOption;
            OptionData optionData(to_string(tempDatum.position), tempDatum.type, "European", true, strExerciseDate);
             if (!isDigital()) {
                commOption = QuantLib::ext::make_shared<CommodityAveragePriceOption>(
                    envelope(), optionData, cf->quantity(), tempDatum.strike, legData_.currency(), commLegData_->name(),
                    commLegData_->priceType(), to_string(start), to_string(cf->endDate()), legData_.paymentCalendar(),
                    legData_.paymentLag(), legData_.paymentConvention(), commLegData_->pricingCalendar(),
                    to_string(cf->date()), cf->gearing(), cf->spread(), cf->quantityFrequency(),
                    CommodityPayRelativeTo::CalculationPeriodEndDate, commLegData_->futureMonthOffset(),
                    commLegData_->deliveryRollDays(), true,
                    tempDatum.type == "Call" ? callBarrierData_ : putBarrierData_, fxIndex_);
             } else {
                 auto undCcy = cf->index()->priceCurve()->currency();
                 QL_REQUIRE(undCcy.code() == legData_.currency(),
                            "Strips of commodity digital options do not support intra-currency trades yet.");
                 commOption = QuantLib::ext::make_shared<CommodityDigitalAveragePriceOption>(
                     envelope(), optionData, tempDatum.strike, cf->quantity() * payoffPerUnit(),
                     legData_.currency(), commLegData_->name(), commLegData_->priceType(), to_string(start),
                     to_string(cf->endDate()), legData_.paymentCalendar(), legData_.paymentLag(),
                     legData_.paymentConvention(), commLegData_->pricingCalendar(), to_string(cf->date()),
                     cf->gearing(), cf->spread(), cf->quantityFrequency(),
                     CommodityPayRelativeTo::CalculationPeriodEndDate, commLegData_->futureMonthOffset(),
                     commLegData_->deliveryRollDays(), true,
                     tempDatum.type == "Call" ? callBarrierData_ : putBarrierData_, fxIndex_);
             }
            commOption->id() = tempDatum.id;
            commOption->build(engineFactory);
            QuantLib::ext::shared_ptr<InstrumentWrapper> instWrapper = commOption->instrument();
            setSensitivityTemplate(commOption->sensitivityTemplate());
            additionalInstruments.push_back(instWrapper->qlInstrument());
            additionalMultipliers.push_back(instWrapper->multiplier());
 
            // Update the notional_ each time. It will hold the notional of the last instrument which is arbitrary
            // but reasonable as this is the instrument that we use as the main instrument below.
            notional_ = commOption->notional();
 
            if (!fxIndex_.empty()) { // if fx is applied, the notional is still quoted in the domestic ccy
                auto underlyingCcy = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(leg[0])->index()->priceCurve()->currency();
                notionalCurrency_ = underlyingCcy.code();
            }
        }
    }
 
    QL_REQUIRE(additionalInstruments.size() > 0, "Expected commodity APO strip to have at least one instrument");
 
    // Take the last option and multiplier as the main instrument
    auto qlInst = additionalInstruments.back();
    auto qlInstMult = additionalMultipliers.back();
    additionalInstruments.pop_back();
    additionalMultipliers.pop_back();
 
    // Possibly add a premium to the additional instruments and multipliers
    // We expect here that the fee already has the correct sign
 
    maturity_ = std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, qlInstMult, premiumData_,
                                                1.0, parseCurrency(legData_.currency()), engineFactory, ""));
    
    // Create the Trade's instrument wrapper
    instrument_ =
        QuantLib::ext::make_shared<VanillaInstrument>(qlInst, qlInstMult, additionalInstruments, additionalMultipliers);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildStandardOptions()

void buildStandardOptions	(	const QuantLib::Leg &	leg,
		const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &	engineFactory
	)

private

Build a standard option strip.

Definition at line 351 of file commodityoptionstrip.cpp.

                                                                                                                         {
 
    QL_REQUIRE(!callBarrierData_.initialized(), "Commodity APO: standard option does not support barriers");
    QL_REQUIRE(!putBarrierData_.initialized(), "Commodity APO: standard option does not support barriers");
 
    // Set style and settlement
    string style = style_.empty() ? "European" : style_;
    string settlement = settlement_.empty() ? "Cash" : settlement_;
 
    // Set automatic exercise to true for cash settlement.
    bool automaticExercise = settlement == "Cash";
 
    // Populate these with the call/put options requested in each period
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
 
    for (Size i = 0; i < leg.size(); i++) {
 
        auto cf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(leg[i]);
        QL_REQUIRE(cf, "Expected a CommodityIndexedCashFlow while building standard option");
 
        // Exercise date is the pricing date.
        Date exerciseDate = cf->pricingDate();
        vector<string> strExerciseDate = {to_string(exerciseDate)};
 
        // If cash settlement and European, create the OptionPaymentData for the OptionData block below.
        boost::optional<OptionPaymentData> paymentData = boost::none;
        if (settlement == "Cash" && style == "European") {
 
            Date paymentDate = cf->date();
            vector<string> strPaymentDate = {to_string(paymentDate)};
            paymentData = OptionPaymentData(strPaymentDate);
 
            // Update the maturity - cash-settled strip, it is the maximum payment date.
            maturity_ = maturity_ == Date() ? paymentDate : max(maturity_, paymentDate);
 
        } else {
            // Update the maturity - physically-settled strip or American, it is the maximum
            // exercise date (no deferred delivery for Physical implemented yet).
            maturity_ = maturity_ == Date() ? exerciseDate : max(maturity_, exerciseDate);
        }
 
        // Populate call and/or put data at this leg period
        vector<TempOptionData> tempData;
        string stemId = id() + "_" + strExerciseDate[0] + "_";
        if (!callStrikes_.empty()) {
            Position::Type position = callPositions_.size() == 1 ? callPositions_[0] : callPositions_[i];
            Real strike = callStrikes_.size() == 1 ? callStrikes_[0] : callStrikes_[i];
            string id = stemId + "call";
            tempData.push_back({"Call", position, strike, id});
        }
        if (!putStrikes_.empty()) {
            Position::Type position = putPositions_.size() == 1 ? putPositions_[0] : putPositions_[i];
            Real strike = putStrikes_.size() == 1 ? putStrikes_[0] : putStrikes_[i];
            string id = stemId + "put";
            tempData.push_back({"Put", position, strike, id});
        }
 
        // Build a commodity option for the call and/or put in this period
        for (const auto& tempDatum : tempData) {
 
            // Check that gearing, strike and spread make sense
            QL_REQUIRE(cf->gearing() > 0.0, "Gearing (" << cf->gearing() << ") should be positive.");
            QL_REQUIRE(cf->spread() < tempDatum.strike || QuantLib::close_enough(cf->spread(), tempDatum.strike),
                       "Spread (" << cf->spread() << ") should be less than strike (" << tempDatum.strike << ").");
 
            TradeStrike effectiveStrike(TradeStrike::Type::Price, (tempDatum.strike - cf->spread()) / cf->gearing());
            Real effectiveQuantity = cf->gearing() * cf->periodQuantity();
 
            OptionData optionData(to_string(tempDatum.position), tempDatum.type, style, false, strExerciseDate,
                                  settlement, "", PremiumData(), {}, {}, "", "", "", {}, {}, "", "", "", "", "",
                                  automaticExercise, boost::none, paymentData);
 
 
            QuantLib::ext::shared_ptr<Trade> commOption;
            if(!isDigital()) {
                commOption = QuantLib::ext::make_shared<CommodityOption>(
                    envelope(), optionData, commLegData_->name(), legData_.currency(), effectiveQuantity,
                    effectiveStrike, cf->useFuturePrice(), cf->index()->expiryDate());
            } else {
                auto undCcy = cf->index()->priceCurve()->currency();
                QL_REQUIRE(undCcy.code() == legData_.currency(), "Strips of commodity digital options do not support intra-currency trades yet.");
                commOption = QuantLib::ext::make_shared<CommodityDigitalOption>(
                    envelope(), optionData, commLegData_->name(), legData_.currency(), effectiveStrike.value(), effectiveQuantity*payoffPerUnit(),
                    cf->useFuturePrice(), cf->index()->expiryDate());
            }
            commOption->id() = tempDatum.id;
            commOption->build(engineFactory);
            QuantLib::ext::shared_ptr<InstrumentWrapper> instWrapper = commOption->instrument();
            setSensitivityTemplate(commOption->sensitivityTemplate());
            additionalInstruments.push_back(instWrapper->qlInstrument());
            additionalMultipliers.push_back(instWrapper->multiplier());
 
            // Update the notional_ each time. It will hold the notional of the last instrument which is arbitrary
            // but reasonable as this is the instrument that we use as the main instrument below.
            notional_ = commOption->notional();
        }
    }
 
    QL_REQUIRE(additionalInstruments.size() > 0, "Expected commodity option strip to have at least one instrument");
 
    // Take the last option and multiplier as the main instrument
    auto qlInst = additionalInstruments.back();
    auto qlInstMult = additionalMultipliers.back();
    additionalInstruments.pop_back();
    additionalMultipliers.pop_back();
 
    // Possibly add a premium to the additional instruments and multipliers
    // We expect here that the fee already has the correct sign
    maturity_ = std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, qlInstMult, premiumData_,
                                                1.0, parseCurrency(legData_.currency()), engineFactory, ""));
    DLOG("Option premium added for commodity option strip " << id());
    
    // Create the Trade's instrument wrapper
    instrument_ =
        QuantLib::ext::make_shared<VanillaInstrument>(qlInst, qlInstMult, additionalInstruments, additionalMultipliers);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check()

void check ( QuantLib::Size numberPeriods ) const

private

Perform checks before building.

Definition at line 469 of file commodityoptionstrip.cpp.

                                                         {
 
    QL_REQUIRE(numberPeriods > 0, "Expected at least one period in the commodity option strip");
    QL_REQUIRE(!callStrikes_.empty() || !putStrikes_.empty(), "Need at least one call or put to build a strip");
 
    if (!callStrikes_.empty()) {
        QL_REQUIRE(callStrikes_.size() == 1 || callStrikes_.size() == numberPeriods,
                   "The number of "
                       << "call strikes (" << callStrikes_.size() << ") should be 1 or equal to "
                       << "the number of periods in the strip (" << numberPeriods << ")");
        QL_REQUIRE(callPositions_.size() == 1 || callPositions_.size() == numberPeriods,
                   "The number of position "
                       << "flags provided with the call strikes (" << callPositions_.size()
                       << ") should be 1 or equal to "
                       << "the number of periods in the strip (" << numberPeriods << ")");
    }
 
    if (!putStrikes_.empty()) {
        QL_REQUIRE(putStrikes_.size() == 1 || putStrikes_.size() == numberPeriods,
                   "The number of "
                       << "put strikes (" << putStrikes_.size() << ") should be 1 or equal to "
                       << "the number of periods in the strip (" << numberPeriods << ")");
        QL_REQUIRE(putPositions_.size() == 1 || putPositions_.size() == numberPeriods,
                   "The number of position "
                       << "flags provided with the put strikes (" << putPositions_.size()
                       << ") should be 1 or equal to "
                       << "the number of periods in the strip (" << numberPeriods << ")");
    }
}

Member Data Documentation

◆ legData_

ore::data::LegData legData_

private

Definition at line 91 of file commodityoptionstrip.hpp.

◆ callPositions_

std::vector<QuantLib::Position::Type> callPositions_

private

Definition at line 92 of file commodityoptionstrip.hpp.

◆ callStrikes_

std::vector<QuantLib::Real> callStrikes_

private

Definition at line 93 of file commodityoptionstrip.hpp.

◆ putPositions_

std::vector<QuantLib::Position::Type> putPositions_

private

Definition at line 94 of file commodityoptionstrip.hpp.

◆ putStrikes_

std::vector<QuantLib::Real> putStrikes_

private

Definition at line 95 of file commodityoptionstrip.hpp.

◆ premiumData_

PremiumData premiumData_

private

Definition at line 96 of file commodityoptionstrip.hpp.

◆ style_

std::string style_

private

Definition at line 97 of file commodityoptionstrip.hpp.

◆ settlement_

std::string settlement_

private

Definition at line 98 of file commodityoptionstrip.hpp.

◆ callBarrierData_

BarrierData callBarrierData_

private

Definition at line 99 of file commodityoptionstrip.hpp.

◆ putBarrierData_

BarrierData putBarrierData_

private

Definition at line 100 of file commodityoptionstrip.hpp.

◆ fxIndex_

std::string fxIndex_

private

Definition at line 101 of file commodityoptionstrip.hpp.

◆ isDigital_

bool isDigital_

private

Definition at line 102 of file commodityoptionstrip.hpp.

◆ unaryPayoff_

Real unaryPayoff_

private

Definition at line 103 of file commodityoptionstrip.hpp.

◆ commLegData_

QuantLib::ext::shared_ptr<CommodityFloatingLegData> commLegData_

private

Definition at line 105 of file commodityoptionstrip.hpp.

Public Member Functions

Trade

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CommodityOptionStrip() [1/2]

◆ CommodityOptionStrip() [2/2]

Member Function Documentation

◆ build()

◆ underlyingIndices()

◆ legData()

◆ callPositions()

◆ callStrikes()

◆ putPositions()

◆ putStrikes()

◆ premiumDate()

◆ style()

◆ settlement()

◆ fxIndex()

◆ callBarrierData()

◆ putBarrierData()

◆ isDigital()

◆ payoffPerUnit()

◆ fromXML()

◆ toXML()

◆ hasCashflows()

◆ buildAPOs()

◆ buildStandardOptions()

◆ check()

Member Data Documentation

◆ legData_

◆ callPositions_

◆ callStrikes_

◆ putPositions_

◆ putStrikes_

◆ premiumData_

◆ style_

◆ settlement_

◆ callBarrierData_

◆ putBarrierData_

◆ fxIndex_

◆ isDigital_

◆ unaryPayoff_

◆ commLegData_