#include <ored/portfolio/commodityapo.hpp>

Inheritance diagram for CommodityAveragePriceOption:

Collaboration diagram for CommodityAveragePriceOption:

Public Member Functions
	CommodityAveragePriceOption ()

	CommodityAveragePriceOption (const ore::data::Envelope &envelope, const ore::data::OptionData &optionData, QuantLib::Real quantity, QuantLib::Real strike, const std::string &currency, const std::string &name, CommodityPriceType priceType, const std::string &startDate, const std::string &endDate, const std::string &paymentCalendar, const std::string &paymentLag, const std::string &paymentConvention, const std::string &pricingCalendar, const std::string &paymentDate="", QuantLib::Real gearing=1.0, QuantLib::Spread spread=0.0, QuantExt::CommodityQuantityFrequency commodityQuantityFrequency=QuantExt::CommodityQuantityFrequency::PerCalculationPeriod, CommodityPayRelativeTo commodityPayRelativeTo=CommodityPayRelativeTo::CalculationPeriodEndDate, QuantLib::Natural futureMonthOffset=0, QuantLib::Natural deliveryRollDays=0, bool includePeriodEnd=true, const BarrierData &barrierData={}, const std::string &fxIndex="")

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

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 &	optionData ()

const ore::data::BarrierData &	barrierData ()

QuantLib::Real	quantity () const

QuantLib::Real	strike () const

const std::string &	currency () const

const std::string &	name () const

CommodityPriceType	priceType () const

const std::string &	startDate () const

const std::string &	endDate () const

const std::string &	paymentCalendar () const

const std::string &	paymentLag () const

const std::string &	paymentConvention () const

const std::string &	pricingCalendar () const

const std::string &	paymentDate () const

QuantLib::Real	gearing () const

QuantLib::Spread	spread () const

QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency () const

CommodityPayRelativeTo	commodityPayRelativeTo () const

QuantLib::Natural	futureMonthOffset () const

QuantLib::Natural	deliveryRollDays () const

bool	includePeriodEnd () const

const std::string &	fxIndex () 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::OptionData	optionData_

ore::data::BarrierData	barrierData_

QuantLib::Real	quantity_

QuantLib::Real	strike_

std::string	currency_

std::string	name_

CommodityPriceType	priceType_

std::string	startDate_

std::string	endDate_

std::string	paymentCalendar_

std::string	paymentLag_

std::string	paymentConvention_

std::string	pricingCalendar_

std::string	paymentDate_

QuantLib::Real	gearing_

QuantLib::Spread	spread_

QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency_

CommodityPayRelativeTo	commodityPayRelativeTo_

QuantLib::Natural	futureMonthOffset_

QuantLib::Natural	deliveryRollDays_

bool	includePeriodEnd_

std::string	fxIndex_

bool	allAveraging_

bool	hasCashflows () const override

QuantLib::Leg	buildLeg (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory, const std::string &configuration)

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

void	buildApo (const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory, const QuantLib::Leg &leg, QuantLib::Date exerciseDate, const QuantLib::ext::shared_ptr< ore::data::EngineBuilder > &builder)
	Build an average price option. 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 Average Price Option

Definition at line 40 of file commodityapo.hpp.

Constructor & Destructor Documentation

◆ CommodityAveragePriceOption() [1/2]

CommodityAveragePriceOption ( )

Definition at line 42 of file commodityapo.hpp.

42: ore::data::Trade("CommodityAveragePriceOption") {}

ore::data::Trade

Trade base class.

Definition: trade.hpp:55

◆ CommodityAveragePriceOption() [2/2]

CommodityAveragePriceOption	(	const ore::data::Envelope &	envelope,
		const ore::data::OptionData &	optionData,
		QuantLib::Real	quantity,
		QuantLib::Real	strike,
		const std::string &	currency,
		const std::string &	name,
		CommodityPriceType	priceType,
		const std::string &	startDate,
		const std::string &	endDate,
		const std::string &	paymentCalendar,
		const std::string &	paymentLag,
		const std::string &	paymentConvention,
		const std::string &	pricingCalendar,
		const std::string &	paymentDate = `""`,
		QuantLib::Real	gearing = `1.0`,
		QuantLib::Spread	spread = `0.0`,
		QuantExt::CommodityQuantityFrequency	commodityQuantityFrequency = `QuantExt::CommodityQuantityFrequency::PerCalculationPeriod`,
		CommodityPayRelativeTo	commodityPayRelativeTo = `CommodityPayRelativeTo::CalculationPeriodEndDate`,
		QuantLib::Natural	futureMonthOffset = `0`,
		QuantLib::Natural	deliveryRollDays = `0`,
		bool	includePeriodEnd = `true`,
		const BarrierData &	barrierData = `{}`,
		const std::string &	fxIndex = `""`
	)

Member Function Documentation

◆ build()

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

override

Definition at line 63 of file commodityapo.cpp.

                                                                                                 {
 
    reset();
 
 
    DLOG("CommodityAveragePriceOption::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();
 
    QL_REQUIRE(gearing_ > 0.0, "Gearing (" << gearing_ << ") should be positive.");
    QL_REQUIRE(spread_ < strike_ || QuantLib::close_enough(spread_, strike_),
               "Spread (" << spread_ << ") should be less than strike (" << strike_ << ").");
 
    additionalData_["quantity"] = quantity_;
    additionalData_["strike"] = strike_;
    additionalData_["strikeCurrency"] = currency_;
 
    // Notional = effective_quantity * effective_strike = (G x Q) x ((K - s) / G) = Q x (K - s)
    notional_ = quantity_ * (strike_ - spread_);
    notionalCurrency_ = npvCurrency_ = currency_;
 
    // Allow exercise dates not to be specified for an APO. In this case, the exercise date is deduced below when
    // building the APO or a standard option.
    Date exDate;
    if (!optionData_.exerciseDates().empty()) {
        QL_REQUIRE(optionData_.exerciseDates().size() == 1, "Commodity average price option must be European");
        exDate = parseDate(optionData_.exerciseDates().front());
    }
 
    // Just to get the configuration string for now
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(
        barrierData_.initialized() ? "CommodityAveragePriceBarrierOption" : "CommodityAveragePriceOption");
    string configuration = builder->configuration(MarketContext::pricing);
 
    // Build the leg. In this method the allAveraging_ flag is set to true if the future itself is averaging and we
    // can then use a standard commodity option pricer below.
    Leg leg = buildLeg(engineFactory, configuration);
 
    // Based on allAveraging_ flag, set up a standard or averaging commodity option
    if (allAveraging_) {
        buildStandardOption(engineFactory, leg, exDate);
    } else {
        buildApo(engineFactory, leg, exDate, builder);
    }
 
    // Add leg to legs_ so that fixings method can work.
    legs_.push_back(leg);
    legPayers_.push_back(false);
    legCurrencies_.push_back(currency_);
}

Here is the call graph for this function:

◆ 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 119 of file commodityapo.cpp.

                                                                                   {
    return {{AssetClass::COM, std::set<std::string>({name_})}};
}

◆ optionData()

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

Definition at line 64 of file commodityapo.hpp.

64{ return optionData_; }

◆ barrierData()

const ore::data::BarrierData & barrierData ( )

Definition at line 65 of file commodityapo.hpp.

65{ return barrierData_; }

◆ quantity()

QuantLib::Real quantity ( ) const

Definition at line 66 of file commodityapo.hpp.

66{ return quantity_; }

◆ strike()

QuantLib::Real strike ( ) const

Definition at line 67 of file commodityapo.hpp.

67{ return strike_; }

◆ currency()

const std::string & currency ( ) const

Definition at line 68 of file commodityapo.hpp.

68{ return currency_; }

◆ name()

const std::string & name ( ) const

Definition at line 69 of file commodityapo.hpp.

69{ return name_; }

◆ priceType()

CommodityPriceType priceType ( ) const

Definition at line 70 of file commodityapo.hpp.

70{ return priceType_; }

ore::data::CommodityAveragePriceOption::priceType_

CommodityPriceType priceType_

Definition: commodityapo.hpp:106

◆ startDate()

const std::string & startDate ( ) const

Definition at line 71 of file commodityapo.hpp.

71{ return startDate_; }

ore::data::CommodityAveragePriceOption::startDate_

std::string startDate_

Definition: commodityapo.hpp:107

◆ endDate()

const std::string & endDate ( ) const

Definition at line 72 of file commodityapo.hpp.

72{ return endDate_; }

ore::data::CommodityAveragePriceOption::endDate_

std::string endDate_

Definition: commodityapo.hpp:108

◆ paymentCalendar()

const std::string & paymentCalendar ( ) const

Definition at line 73 of file commodityapo.hpp.

73{ return paymentCalendar_; }

ore::data::CommodityAveragePriceOption::paymentCalendar_

std::string paymentCalendar_

Definition: commodityapo.hpp:109

◆ paymentLag()

const std::string & paymentLag ( ) const

Definition at line 74 of file commodityapo.hpp.

74{ return paymentLag_; }

ore::data::CommodityAveragePriceOption::paymentLag_

std::string paymentLag_

Definition: commodityapo.hpp:110

◆ paymentConvention()

const std::string & paymentConvention ( ) const

Definition at line 75 of file commodityapo.hpp.

75{ return paymentConvention_; }

ore::data::CommodityAveragePriceOption::paymentConvention_

std::string paymentConvention_

Definition: commodityapo.hpp:111

◆ pricingCalendar()

const std::string & pricingCalendar ( ) const

Definition at line 76 of file commodityapo.hpp.

76{ return pricingCalendar_; }

ore::data::CommodityAveragePriceOption::pricingCalendar_

std::string pricingCalendar_

Definition: commodityapo.hpp:112

◆ paymentDate()

const std::string & paymentDate ( ) const

Definition at line 77 of file commodityapo.hpp.

77{ return paymentDate_; }

ore::data::CommodityAveragePriceOption::paymentDate_

std::string paymentDate_

Definition: commodityapo.hpp:113

◆ gearing()

QuantLib::Real gearing ( ) const

Definition at line 78 of file commodityapo.hpp.

78{ return gearing_; }

ore::data::CommodityAveragePriceOption::gearing_

QuantLib::Real gearing_

Definition: commodityapo.hpp:114

◆ spread()

QuantLib::Spread spread ( ) const

Definition at line 79 of file commodityapo.hpp.

79{ return spread_; }

◆ commodityQuantityFrequency()

QuantExt::CommodityQuantityFrequency commodityQuantityFrequency ( ) const

Definition at line 80 of file commodityapo.hpp.

80{ return commodityQuantityFrequency_; }

ore::data::CommodityAveragePriceOption::commodityQuantityFrequency_

QuantExt::CommodityQuantityFrequency commodityQuantityFrequency_

Definition: commodityapo.hpp:116

◆ commodityPayRelativeTo()

CommodityPayRelativeTo commodityPayRelativeTo ( ) const

Definition at line 81 of file commodityapo.hpp.

81{ return commodityPayRelativeTo_; }

ore::data::CommodityAveragePriceOption::commodityPayRelativeTo_

CommodityPayRelativeTo commodityPayRelativeTo_

Definition: commodityapo.hpp:117

◆ futureMonthOffset()

QuantLib::Natural futureMonthOffset ( ) const

Definition at line 82 of file commodityapo.hpp.

82{ return futureMonthOffset_; }

ore::data::CommodityAveragePriceOption::futureMonthOffset_

QuantLib::Natural futureMonthOffset_

Definition: commodityapo.hpp:118

◆ deliveryRollDays()

QuantLib::Natural deliveryRollDays ( ) const

Definition at line 83 of file commodityapo.hpp.

83{ return deliveryRollDays_; }

ore::data::CommodityAveragePriceOption::deliveryRollDays_

QuantLib::Natural deliveryRollDays_

Definition: commodityapo.hpp:119

◆ includePeriodEnd()

bool includePeriodEnd ( ) const

Definition at line 84 of file commodityapo.hpp.

84{ return includePeriodEnd_; }

ore::data::CommodityAveragePriceOption::includePeriodEnd_

bool includePeriodEnd_

Definition: commodityapo.hpp:120

◆ fxIndex()

const std::string & fxIndex ( ) const

Definition at line 85 of file commodityapo.hpp.

85{ return fxIndex_; }

QuantExt::CommodityAveragePriceOption::fxIndex_

boost::shared_ptr< FxIndex > fxIndex_

◆ fromXML()

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

overridevirtual

Reimplemented from Trade.

Definition at line 124 of file commodityapo.cpp.

                                                       {
 
    Trade::fromXML(node);
 
    XMLNode* apoNode = XMLUtils::getChildNode(node, "CommodityAveragePriceOptionData");
    QL_REQUIRE(apoNode, "No CommodityAveragePriceOptionData Node");
 
    optionData_.fromXML(XMLUtils::getChildNode(apoNode, "OptionData"));
    if(auto b = XMLUtils::getChildNode(apoNode, "BarrierData")) {
        barrierData_.fromXML(b);
    }
    name_ = XMLUtils::getChildValue(apoNode, "Name", true);
    currency_ = XMLUtils::getChildValue(apoNode, "Currency", true);
    quantity_ = XMLUtils::getChildValueAsDouble(apoNode, "Quantity", true);
    strike_ = XMLUtils::getChildValueAsDouble(apoNode, "Strike", true);
    priceType_ = parseCommodityPriceType(XMLUtils::getChildValue(apoNode, "PriceType", true));
    startDate_ = XMLUtils::getChildValue(apoNode, "StartDate", true);
    endDate_ = XMLUtils::getChildValue(apoNode, "EndDate", true);
    paymentCalendar_ = XMLUtils::getChildValue(apoNode, "PaymentCalendar", true);
    paymentLag_ = XMLUtils::getChildValue(apoNode, "PaymentLag", true);
    paymentConvention_ = XMLUtils::getChildValue(apoNode, "PaymentConvention", true);
    pricingCalendar_ = XMLUtils::getChildValue(apoNode, "PricingCalendar", true);
 
    paymentDate_ = XMLUtils::getChildValue(apoNode, "PaymentDate", false);
 
    gearing_ = 1.0;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "Gearing")) {
        gearing_ = parseReal(XMLUtils::getNodeValue(n));
    }
 
    spread_ = XMLUtils::getChildValueAsDouble(apoNode, "Spread", false);
 
    commodityQuantityFrequency_ = CommodityQuantityFrequency::PerCalculationPeriod;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "CommodityQuantityFrequency")) {
        commodityQuantityFrequency_ = parseCommodityQuantityFrequency(XMLUtils::getNodeValue(n));
    }
 
    commodityPayRelativeTo_ = CommodityPayRelativeTo::CalculationPeriodEndDate;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "CommodityPayRelativeTo")) {
        commodityPayRelativeTo_ = parseCommodityPayRelativeTo(XMLUtils::getNodeValue(n));
    }
 
    futureMonthOffset_ = XMLUtils::getChildValueAsInt(apoNode, "FutureMonthOffset", false);
    deliveryRollDays_ = XMLUtils::getChildValueAsInt(apoNode, "DeliveryRollDays", false);
 
    includePeriodEnd_ = true;
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "IncludePeriodEnd")) {
        includePeriodEnd_ = parseBool(XMLUtils::getNodeValue(n));
    }
 
    if (XMLNode* n = XMLUtils::getChildNode(apoNode, "FXIndex")){
        fxIndex_ = 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 179 of file commodityapo.cpp.

                                                                  {
 
    XMLNode* node = Trade::toXML(doc);
 
    XMLNode* apoNode = doc.allocNode("CommodityAveragePriceOptionData");
    XMLUtils::appendNode(node, apoNode);
 
    XMLUtils::appendNode(apoNode, optionData_.toXML(doc));
    if (barrierData_.initialized())
        XMLUtils::appendNode(apoNode, barrierData_.toXML(doc));
    XMLUtils::addChild(doc, apoNode, "Name", name_);
    XMLUtils::addChild(doc, apoNode, "Currency", currency_);
    XMLUtils::addChild(doc, apoNode, "Quantity", quantity_);
    XMLUtils::addChild(doc, apoNode, "Strike", strike_);
    XMLUtils::addChild(doc, apoNode, "PriceType", to_string(priceType_));
    XMLUtils::addChild(doc, apoNode, "StartDate", startDate_);
    XMLUtils::addChild(doc, apoNode, "EndDate", endDate_);
    XMLUtils::addChild(doc, apoNode, "PaymentCalendar", paymentCalendar_);
    XMLUtils::addChild(doc, apoNode, "PaymentLag", paymentLag_);
    XMLUtils::addChild(doc, apoNode, "PaymentConvention", paymentConvention_);
    XMLUtils::addChild(doc, apoNode, "PricingCalendar", pricingCalendar_);
    XMLUtils::addChild(doc, apoNode, "PaymentDate", paymentDate_);
    XMLUtils::addChild(doc, apoNode, "Gearing", gearing_);
    XMLUtils::addChild(doc, apoNode, "Spread", spread_);
    XMLUtils::addChild(doc, apoNode, "CommodityQuantityFrequency", to_string(commodityQuantityFrequency_));
    XMLUtils::addChild(doc, apoNode, "CommodityPayRelativeTo", to_string(commodityPayRelativeTo_));
    XMLUtils::addChild(doc, apoNode, "FutureMonthOffset", static_cast<int>(futureMonthOffset_));
    XMLUtils::addChild(doc, apoNode, "DeliveryRollDays", static_cast<int>(deliveryRollDays_));
    XMLUtils::addChild(doc, apoNode, "IncludePeriodEnd", includePeriodEnd_);
    if(!fxIndex_.empty()){
        XMLUtils::addChild(doc, apoNode, "FXIndex", fxIndex_);
    }
 
    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 96 of file commodityapo.hpp.

96{ return false; }

◆ buildLeg()

Leg buildLeg	(	const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &	engineFactory,
		const std::string &	configuration
	)

private

Build a commodity floating leg to extract the single commodity averaging flow

Definition at line 215 of file commodityapo.cpp.

                                                                       {
 
    // Create the ScheduleData for use in the LegData. Tenor is not needed.
    ScheduleData scheduleData(ScheduleDates("NullCalendar", "Unadjusted", "", {startDate_, endDate_}));
 
    // Create the CommodityFloatingLegData. Want to generate a single averaging commodity coupon.
    vector<Real> quantities{quantity_};
    vector<string> quantityDates;
    vector<Real> spreads{spread_};
    vector<string> spreadDates;
    vector<Real> gearings{gearing_};
    vector<string> gearingDates;
    vector<string> pricingDates;
    bool isAveraged = true;
    bool isInArrears = false;
    QuantLib::ext::shared_ptr<CommodityFloatingLegData> commLegData = QuantLib::ext::make_shared<CommodityFloatingLegData>(
        name_, priceType_, quantities, quantityDates, commodityQuantityFrequency_, commodityPayRelativeTo_, spreads,
        spreadDates, gearings, gearingDates, CommodityPricingDateRule::FutureExpiryDate, pricingCalendar_, 0,
        pricingDates, isAveraged, isInArrears, futureMonthOffset_, deliveryRollDays_, includePeriodEnd_, true,
        QuantLib::Null<QuantLib::Natural>(), true, "", QuantLib::Null<QuantLib::Natural>(), false, QuantLib::Null<QuantLib::Natural>(),
            fxIndex_);
 
    // Create the LegData. All defaults are as in the LegData ctor.
    vector<string> paymentDates = paymentDate_.empty() ? vector<string>() : vector<string>(1, paymentDate_);
    LegData legData(commLegData, true, currency_, scheduleData, "", vector<Real>(), vector<string>(),
                    paymentConvention_, false, false, false, true, "", 0, "", vector<AmortizationData>(), 
                    paymentLag_, "", paymentCalendar_, paymentDates);
 
    // Get the leg builder, set the allAveraging_ flag and build the leg
    auto legBuilder = engineFactory->legBuilder(legData.legType());
    QuantLib::ext::shared_ptr<CommodityFloatingLegBuilder> 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_, configuration);
    allAveraging_ = cflb->allAveraging();
 
    return leg;
}

Here is the call graph for this function:

◆ buildStandardOption()

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

private

Build a standard option.

Definition at line 255 of file commodityapo.cpp.

                                                                                         {
 
    QL_REQUIRE(!barrierData_.initialized(), "Commodity APO: standard option does not support barriers");
 
    // Expect the leg to hold a single commodity averaging cashflow on which the option is written
    QL_REQUIRE(leg.size() == 1, "Single flow expected but found " << leg.size());
    auto flow = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(leg[0]);
    QL_REQUIRE(flow, "Expected a cashflow of type CommodityIndexedCashFlow");
 
    // If exercise date is given use it. If not given, take the cashflow's pricing date.
    if (exerciseDate != Date()) {
        QL_REQUIRE(exerciseDate >= flow->pricingDate(),
                   "Exercise date, " << io::iso_date(exerciseDate) << ", should be on or after the pricing date, "
                                     << io::iso_date(flow->pricingDate()));
        DLOG("buildStandardOption: explicit exercise date given for APO " << io::iso_date(exerciseDate) << ".");
    } else {
        exerciseDate = flow->pricingDate();
        optionData_.setExerciseDates({to_string(exerciseDate)});
        DLOG("buildStandardOption: set exercise date on APO to cashflow's pricing date " << io::iso_date(exerciseDate)
                                                                                         << ".");
    }
    DLOG("buildStandardOption: pricing date on APO is " << io::iso_date(flow->pricingDate()) << ".");
 
    // Update the optionData_ if necessary
    if (!optionData_.automaticExercise()) {
        optionData_.setAutomaticExercise(true);
        DLOG("buildStandardOption: setting automatic exercise to true on APO.");
    }
 
    if (!optionData_.paymentData()) {
        QL_REQUIRE(exerciseDate <= flow->date(), "Exercise date, " << io::iso_date(exerciseDate)
                                                                   << ", should be on or before payment date, "
                                                                   << io::iso_date(flow->date()));
        string strDate = to_string(flow->date());
        optionData_.setPaymentData(OptionPaymentData({strDate}));
        DLOG("buildStandardOption: setting payment date to " << strDate << " on APO.");
    } else {
        DLOG("buildStandardOption: using explicitly provided payment data on APO.");
    }
 
    // Build the commodity option.
    TradeStrike effectiveStrike((strike_ - spread_) / gearing_, currency_);
    Real effectiveQuantity = gearing_ * quantity_;
    CommodityOption commOption(envelope(), optionData_, name_, currency_, effectiveQuantity, effectiveStrike,
                               flow->index()->isFuturesIndex(), flow->pricingDate());
    commOption.build(engineFactory);
    setSensitivityTemplate(commOption.sensitivityTemplate());
    instrument_ = commOption.instrument();
    maturity_ = commOption.maturity();
}

Here is the call graph for this function:

◆ buildApo()

void buildApo	(	const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &	engineFactory,
		const QuantLib::Leg &	leg,
		QuantLib::Date	exerciseDate,
		const QuantLib::ext::shared_ptr< ore::data::EngineBuilder > &	builder
	)

private

Build an average price option.

Definition at line 307 of file commodityapo.cpp.

                                                                                                                   {
 
    // Expect the leg to hold a single commodity averaging cashflow on which the option is written
    QL_REQUIRE(leg.size() == 1, "Single flow expected but found " << leg.size());
    auto apoFlow = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(leg[0]);
    QL_REQUIRE(apoFlow, "Expected a cashflow of type CommodityIndexedAverageCashFlow");
 
    // Populate relevant Trade members
    maturity_ = std::max(optionData_.premiumData().latestPremiumDate(), apoFlow->date());
    
    Date lastApoFixingDate = apoFlow->indices().rbegin()->first;
 
    // If exercise date is given use it. If not given, take the cashflow's last pricing date.
    if (exerciseDate != Date()) {
        QL_REQUIRE(exerciseDate >= lastApoFixingDate, "Exercise date, "
                                                          << io::iso_date(exerciseDate)
                                                          << ", should be on or after the last APO fixing date, "
                                                          << io::iso_date(lastApoFixingDate));
        DLOG("buildApo: explicit exercise date given for APO " << io::iso_date(exerciseDate) << ".");
    } else {
        exerciseDate = lastApoFixingDate;
        string strDate = to_string(lastApoFixingDate);
        optionData_.setExerciseDates({strDate});
        DLOG("buildApo: set exercise date on APO to cashflow's last pricing date " << io::iso_date(lastApoFixingDate)
                                                                                   << ".");
    }
    DLOG("buildApo: pricing date on APO is " << io::iso_date(lastApoFixingDate) << ".");
 
    QL_REQUIRE(exerciseDate <= apoFlow->date(), "Exercise date, " << io::iso_date(exerciseDate)
                                                                  << ", should be on or before payment date, "
                                                                  << io::iso_date(apoFlow->date()));
 
    // If the apo is payout and the underlying are quoted in different currencies, handle the fxIndex
    QuantLib::ext::shared_ptr<FxIndex> fxIndex;
    if(!fxIndex_.empty()) {
        auto underlyingCcy =
            QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(leg[0])->index()->priceCurve()->currency();
        // check currencies consistency
        QL_REQUIRE(npvCurrency_ == underlyingCcy.code() || npvCurrency_ == currency_, "Commodity cross-currency APO: inconsistent currencies in trade.");
        
        // only add an fx index if underlying currency differs from trade currency
        if (npvCurrency_ != underlyingCcy.code()) {
            fxIndex = buildFxIndex(fxIndex_, npvCurrency_, underlyingCcy.code(), engineFactory->market(),
                                   engineFactory->configuration(MarketContext::pricing));
            for (auto cf : leg) { // request appropriate fixings
                auto cacf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(cf);
                for (auto kv : cacf->indices()) {
                    if (!fxIndex->fixingCalendar().isBusinessDay(
                            kv.first)) { // If fx index is not available for the commodity pricing day,
                                         // this ensures to require the previous valid one which will be used in pricing
                                         // from fxIndex()->fixing(...)
                        Date adjustedFixingDate = fxIndex->fixingCalendar().adjust(kv.first, Preceding);
                        requiredFixings_.addFixingDate(adjustedFixingDate, fxIndex_);
 
                    } else {
                        requiredFixings_.addFixingDate(kv.first, fxIndex_);
                    }
                }
            }
        }
    }
 
    // get barrier info
    Real barrierLevel = Null<Real>();
    Barrier::Type barrierType = Barrier::DownIn;
    Exercise::Type barrierStyle = Exercise::American;
    if (barrierData_.initialized()) {
        QL_REQUIRE(barrierData_.levels().size() == 1, "Commodity APO: Expected exactly one barrier level.");
        barrierLevel = barrierData_.levels().front().value();
        barrierType = parseBarrierType(barrierData_.type());
        if (!barrierData_.style().empty()) {
            barrierStyle = parseExerciseType(barrierData_.style());
            QL_REQUIRE(barrierStyle == Exercise::European || barrierStyle == Exercise::American,
                       "Commodity APO: Expected 'European' or 'American' as barrier style");
        }
    }
 
    // Create the APO instrument
    QuantLib::ext::shared_ptr<QuantLib::Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(exerciseDate);
    auto apo = QuantLib::ext::make_shared<QuantExt::CommodityAveragePriceOption>(
        apoFlow, exercise, apoFlow->periodQuantity(), strike_, parseOptionType(optionData_.callPut()),
        Settlement::Physical, Settlement::PhysicalOTC, barrierLevel, barrierType, barrierStyle, fxIndex);
 
    // Set the pricing engine
    Currency ccy = parseCurrency(currency_);
    auto engineBuilder = QuantLib::ext::dynamic_pointer_cast<CommodityApoBaseEngineBuilder>(builder);
    QuantLib::ext::shared_ptr<PricingEngine> engine = engineBuilder->engine(ccy, name_, id(), apo);
    apo->setPricingEngine(engine);
    setSensitivityTemplate(*engineBuilder);
 
    // position type and trade multiplier
    Position::Type positionType = parsePositionType(optionData_.longShort());
    Real multiplier = positionType == Position::Long ? 1.0 : -1.0;
 
    // Take care of fees
    vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    vector<Real> additionalMultipliers;
    addPremiums(additionalInstruments, additionalMultipliers, multiplier, optionData_.premiumData(),
                positionType == Position::Long ? -1.0 : 1.0, ccy, engineFactory,
                engineBuilder->configuration(MarketContext::pricing));
 
    // Populate instrument wrapper
    instrument_ = QuantLib::ext::make_shared<VanillaInstrument>(apo, multiplier, additionalInstruments, additionalMultipliers);
}

Here is the call graph for this function:

Member Data Documentation

◆ optionData_

ore::data::OptionData optionData_

private

Definition at line 100 of file commodityapo.hpp.

◆ barrierData_

ore::data::BarrierData barrierData_

private

Definition at line 101 of file commodityapo.hpp.

◆ quantity_

QuantLib::Real quantity_

private

Definition at line 102 of file commodityapo.hpp.

◆ strike_

QuantLib::Real strike_

private

Definition at line 103 of file commodityapo.hpp.

◆ currency_

std::string currency_

private

Definition at line 104 of file commodityapo.hpp.

◆ name_

std::string name_

private

Definition at line 105 of file commodityapo.hpp.

◆ priceType_

CommodityPriceType priceType_

private

Definition at line 106 of file commodityapo.hpp.

◆ startDate_

std::string startDate_

private

Definition at line 107 of file commodityapo.hpp.

◆ endDate_

std::string endDate_

private

Definition at line 108 of file commodityapo.hpp.

◆ paymentCalendar_

std::string paymentCalendar_

private

Definition at line 109 of file commodityapo.hpp.

◆ paymentLag_

std::string paymentLag_

private

Definition at line 110 of file commodityapo.hpp.

◆ paymentConvention_

std::string paymentConvention_

private

Definition at line 111 of file commodityapo.hpp.

◆ pricingCalendar_

std::string pricingCalendar_

private

Definition at line 112 of file commodityapo.hpp.

◆ paymentDate_

std::string paymentDate_

private

Definition at line 113 of file commodityapo.hpp.

◆ gearing_

QuantLib::Real gearing_

private

Definition at line 114 of file commodityapo.hpp.

◆ spread_

QuantLib::Spread spread_

private

Definition at line 115 of file commodityapo.hpp.

◆ commodityQuantityFrequency_

QuantExt::CommodityQuantityFrequency commodityQuantityFrequency_

private

Definition at line 116 of file commodityapo.hpp.

◆ commodityPayRelativeTo_

CommodityPayRelativeTo commodityPayRelativeTo_

private

Definition at line 117 of file commodityapo.hpp.

◆ futureMonthOffset_

QuantLib::Natural futureMonthOffset_

private

Definition at line 118 of file commodityapo.hpp.

◆ deliveryRollDays_

QuantLib::Natural deliveryRollDays_

private

Definition at line 119 of file commodityapo.hpp.

◆ includePeriodEnd_

bool includePeriodEnd_

private

Definition at line 120 of file commodityapo.hpp.

◆ fxIndex_

std::string fxIndex_

private

Definition at line 121 of file commodityapo.hpp.

◆ allAveraging_

bool allAveraging_

private

Flag indicating if the commodity contract itself is averaging. This is used to decide if we build a standard non-averaging commodity option or an averaging commodity option.

Definition at line 126 of file commodityapo.hpp.

Public Member Functions

Trade

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CommodityAveragePriceOption() [1/2]

◆ CommodityAveragePriceOption() [2/2]

Member Function Documentation

◆ build()

◆ underlyingIndices()

◆ optionData()

◆ barrierData()

◆ quantity()

◆ strike()

◆ currency()

◆ name()

◆ priceType()

◆ startDate()

◆ endDate()

◆ paymentCalendar()

◆ paymentLag()

◆ paymentConvention()

◆ pricingCalendar()

◆ paymentDate()

◆ gearing()

◆ spread()

◆ commodityQuantityFrequency()

◆ commodityPayRelativeTo()

◆ futureMonthOffset()

◆ deliveryRollDays()

◆ includePeriodEnd()

◆ fxIndex()

◆ fromXML()

◆ toXML()

◆ hasCashflows()

◆ buildLeg()

◆ buildStandardOption()

◆ buildApo()

Member Data Documentation

◆ optionData_

◆ barrierData_

◆ quantity_

◆ strike_

◆ currency_

◆ name_

◆ priceType_

◆ startDate_

◆ endDate_

◆ paymentCalendar_

◆ paymentLag_

◆ paymentConvention_

◆ pricingCalendar_

◆ paymentDate_

◆ gearing_

◆ spread_

◆ commodityQuantityFrequency_

◆ commodityPayRelativeTo_

◆ futureMonthOffset_

◆ deliveryRollDays_

◆ includePeriodEnd_

◆ fxIndex_

◆ allAveraging_