Serializable Vanilla Option. More...

#include <ored/portfolio/vanillaoption.hpp>

Inheritance diagram for VanillaOptionTrade:

Collaboration diagram for VanillaOptionTrade:

Public Member Functions
void	build (const QuantLib::ext::shared_ptr< EngineFactory > &) override
	Build QuantLib/QuantExt instrument, link pricing engine. More...

void	setNotionalAndCurrencies ()

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

virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

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

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

Inspectors
AssetClass	assetClassUnderlying_

OptionData	option_

string	assetName_

string	currency_

Currency	underlyingCurrency_

double	quantity_

TradeStrike	strike_

QuantLib::ext::shared_ptr< QuantLib::Index >	index_
	An index is needed if the option is to be automatically exercised on expiry. More...

std::string	indexName_
	Hold the external index name if needed e.g. in the case of an FX index. More...

QuantLib::Date	expiryDate_
	Store the option expiry date. More...

QuantLib::Date	forwardDate_
	Store the (optional) forward date. More...

QuantLib::Date	paymentDate_
	Store the (optional) payment date. More...

const OptionData &	option () const

const string &	asset () const

const string &	currency () const

TradeStrike	strike () const

double	quantity () const

const QuantLib::Date	forwardDate () const

const QuantLib::Date	paymentDate () const

	VanillaOptionTrade (AssetClass assetClassUnderlying)

	VanillaOptionTrade (const Envelope &env, AssetClass assetClassUnderlying, OptionData option, string assetName, string currency, double quantity, TradeStrike strike, const QuantLib::ext::shared_ptr< QuantLib::Index > &index=nullptr, const std::string &indexName="", QuantLib::Date forwardDate=QuantLib::Date())

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

Definition at line 39 of file vanillaoption.hpp.

Constructor & Destructor Documentation

◆ VanillaOptionTrade() [1/2]

VanillaOptionTrade ( AssetClass assetClassUnderlying )

protected

Definition at line 57 of file vanillaoption.hpp.

58 : Trade("VanillaOption"), assetClassUnderlying_(assetClassUnderlying), quantity_(0) {}

ore::data::Trade::Trade

Trade()

Default constructor.

Definition: trade.hpp:59

ore::data::VanillaOptionTrade::assetClassUnderlying_

AssetClass assetClassUnderlying_

Definition: vanillaoption.hpp:67

ore::data::VanillaOptionTrade::quantity_

double quantity_

Definition: vanillaoption.hpp:72

◆ VanillaOptionTrade() [2/2]

VanillaOptionTrade	(	const Envelope &	env,
		AssetClass	assetClassUnderlying,
		OptionData	option,
		string	assetName,
		string	currency,
		double	quantity,
		TradeStrike	strike,
		const QuantLib::ext::shared_ptr< QuantLib::Index > &	index = `nullptr`,
		const std::string &	indexName = `""`,
		QuantLib::Date	forwardDate = `QuantLib::Date()`
	)

protected

Definition at line 59 of file vanillaoption.hpp.

        : Trade("VanillaOption", env), assetClassUnderlying_(assetClassUnderlying), option_(option),
          assetName_(assetName), currency_(currency), quantity_(quantity), strike_(strike), index_(index),
          indexName_(indexName), forwardDate_(forwardDate) {}

Member Function Documentation

◆ build()

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

overridevirtual

Build QuantLib/QuantExt instrument, link pricing engine.

Implements Trade.

Definition at line 39 of file vanillaoption.cpp.

                                                                                               {
    setNotionalAndCurrencies();
 
    QL_REQUIRE(tradeActions().empty(), "TradeActions not supported for VanillaOption");
 
    // If underlying currency is empty, then set to payment currency by default.
    // If non-empty, then check if the currencies are different for a Quanto payoff
    Currency ccy = parseCurrencyWithMinors(currency_);
    Currency underlyingCurrency = underlyingCurrency_.empty() ? ccy : underlyingCurrency_;
    bool sameCcy = underlyingCurrency == ccy;
    
    if (strike_.currency().empty())
        strike_.setCurrency(ccy.code());
 
    // Payoff
    Option::Type type = parseOptionType(option_.callPut());
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike_.value()));
    QuantLib::Exercise::Type exerciseType = parseExerciseType(option_.style());
    QL_REQUIRE(option_.exerciseDates().size() == 1, "Invalid number of exercise dates");
    expiryDate_ = parseDate(option_.exerciseDates().front());
    // Set the maturity date equal to the expiry date. It may get updated below if option is cash settled with
    // payment after expiry.
    maturity_ = expiryDate_;
    // Exercise
    QuantLib::ext::shared_ptr<Exercise> exercise;
    switch (exerciseType) {
    case QuantLib::Exercise::Type::European: {
        exercise = QuantLib::ext::make_shared<EuropeanExercise>(expiryDate_);
        break;
    }
    case QuantLib::Exercise::Type::American: {
        exercise = QuantLib::ext::make_shared<AmericanExercise>(expiryDate_, option_.payoffAtExpiry());
        break;
    }
    default:
        QL_FAIL("Option Style " << option_.style() << " is not supported");
    }
    // Create the instrument and then populate the name for the engine builder.
    QuantLib::ext::shared_ptr<Instrument> vanilla;
    string tradeTypeBuilder = tradeType_;
    Settlement::Type settlementType = parseSettlementType(option_.settlement());
 
    // For Quanto, check for European and Cash, except for an FX underlying
    if (!sameCcy) {
        QL_REQUIRE(exerciseType == Exercise::Type::European, "Option exercise must be European for a Quanto payoff.");
        if (settlementType == Settlement::Type::Physical) {
            QL_REQUIRE(assetClassUnderlying_ == AssetClass::FX,
                       "Physically settled Quanto options are allowed only for an FX underlying.");
        }
    }
 
    if (exerciseType == Exercise::European && settlementType == Settlement::Cash) {
        // We have a European cash settled option.
 
        // Get the payment date.
        const boost::optional<OptionPaymentData>& opd = option_.paymentData();
        Date paymentDate = expiryDate_;
        if (opd) {
            if (opd->rulesBased()) {
                const Calendar& cal = opd->calendar();
                QL_REQUIRE(cal != Calendar(), "Need a non-empty calendar for rules based payment date.");
                paymentDate = cal.advance(expiryDate_, opd->lag(), Days, opd->convention());
            } else {
                const vector<Date>& dates = opd->dates();
                QL_REQUIRE(dates.size() == 1, "Need exactly one payment date for cash settled European option.");
                paymentDate = dates[0];
            }
            QL_REQUIRE(paymentDate >= expiryDate_, "Payment date must be greater than or equal to expiry date.");
        }
 
        if (paymentDate > expiryDate_) {
            QL_REQUIRE(sameCcy, "Payment date must equal expiry date for a Quanto payoff. Trade: " << id() << ".");
 
            // Build a QuantExt::CashSettledEuropeanOption if payment date is strictly greater than expiry.
 
            // Has the option been marked as exercised
            const boost::optional<OptionExerciseData>& oed = option_.exerciseData();
            bool exercised = false;
            Real exercisePrice = Null<Real>();
            if (oed) {
                QL_REQUIRE(oed->date() == expiryDate_, "The supplied exercise date ("
                                                           << io::iso_date(oed->date())
                                                           << ") should equal the option's expiry date ("
                                                           << io::iso_date(expiryDate_) << ").");
                exercised = true;
                exercisePrice = oed->price();
            }
 
            // If automatic exercise, we will need an index fixing on the expiry date.
            if (option_.isAutomaticExercise()) {
                QL_REQUIRE(index_, "Option trade " << id() << " has automatic exercise so we need a valid index.");
                // If index name has not been populated, use logic here to populate it from the index object.
                string indexName = indexName_;
                if (indexName.empty()) {
                    indexName = index_->name();
                    if (assetClassUnderlying_ == AssetClass::EQ)
                        indexName = "EQ-" + indexName;
                }
                requiredFixings_.addFixingDate(expiryDate_, indexName, paymentDate);
            }
 
            // Build the instrument
            LOG("Build CashSettledEuropeanOption for trade " << id());
            vanilla = QuantLib::ext::make_shared<CashSettledEuropeanOption>(
                type, strike_.value(), expiryDate_, paymentDate, option_.isAutomaticExercise(), index_, exercised, exercisePrice);
 
            // Allow for a separate pricing engine that takes care of payment on a date after expiry. Do this by
            // appending 'EuropeanCS' to the trade type.
            tradeTypeBuilder = tradeType_ + "EuropeanCS";
 
            // Update the maturity date.
            maturity_ = paymentDate;
 
        } else {
            if (forwardDate_ == QuantLib::Date()) {
                // If payment date is not greater than expiry, build QuantLib::VanillaOption.
                if (sameCcy) {
                    LOG("Build VanillaOption for trade " << id());
                    vanilla = QuantLib::ext::make_shared<QuantLib::VanillaOption>(payoff, exercise);
                }
                else {
                    LOG("Build QuantoVanillaOption for trade " << id());
                    vanilla = QuantLib::ext::make_shared<QuantLib::QuantoVanillaOption>(payoff, exercise);
                    if (assetClassUnderlying_ == AssetClass::EQ)
                        tradeTypeBuilder = "QuantoEquityOption";
                    else if (assetClassUnderlying_ == AssetClass::COM)
                        tradeTypeBuilder = "QuantoCommodityOption";
                    else
                        QL_FAIL("Option Quanto payoff not supported for " << assetClassUnderlying_ << " class.");
                }
            } else {
                LOG("Build VanillaForwardOption for trade " << id());
                QL_REQUIRE(sameCcy, "Quanto payoff is not currently supported for Forward Options: Trade " << id());
                vanilla = QuantLib::ext::make_shared<QuantExt::VanillaForwardOption>(payoff, exercise, forwardDate_);
                if (assetClassUnderlying_ == AssetClass::COM)
                    tradeTypeBuilder = tradeType_ + "Forward";
            }
        }
 
    } else {
        if (forwardDate_ == QuantLib::Date()) {
            // If not European or not cash settled, build QuantLib::VanillaOption.
            if (sameCcy) {
                LOG("Build VanillaOption for trade " << id());
                vanilla = QuantLib::ext::make_shared<QuantLib::VanillaOption>(payoff, exercise);
            } else {
                LOG("Build QuantoVanillaOption for trade " << id());
                vanilla = QuantLib::ext::make_shared<QuantLib::QuantoVanillaOption>(payoff, exercise);
            }
        } else {
            QL_REQUIRE(exerciseType == QuantLib::Exercise::Type::European, "Only European Forward Options currently supported");
            LOG("Built VanillaForwardOption for trade " << id());
            vanilla = QuantLib::ext::make_shared<QuantExt::VanillaForwardOption>(payoff, exercise, forwardDate_, paymentDate_);
            if (assetClassUnderlying_ == AssetClass::COM)
                tradeTypeBuilder = tradeType_ + "Forward";
        }
 
        // If the tradeTypeBuilder has not been modified yet..
        if (tradeTypeBuilder == tradeType_) {
            if (sameCcy)
                tradeTypeBuilder = tradeType_ + (exerciseType == QuantLib::Exercise::Type::European ? "" : "American");
            else
                tradeTypeBuilder = "QuantoFxOption";
        }
    }
    LOG("tradeTypeBuilder set to " << tradeTypeBuilder << " for trade " << id());
 
    // Generally we need to set the pricing engine here even if the option is expired at build time, since the valuation date
    // might change after build, and we get errors for the edge case valuation date = expiry date for European options.
    string configuration = Market::defaultConfiguration;
    QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder(tradeTypeBuilder);
    QL_REQUIRE(builder, "No builder found for " << tradeTypeBuilder);
 
    if (sameCcy) {
        QuantLib::ext::shared_ptr<VanillaOptionEngineBuilder> vanillaOptionBuilder =
                QuantLib::ext::dynamic_pointer_cast<VanillaOptionEngineBuilder>(builder);
    QL_REQUIRE(vanillaOptionBuilder != nullptr, "No engine builder found for trade type " << tradeTypeBuilder);
 
    if (forwardDate_ != Date()) {
        vanilla->setPricingEngine(vanillaOptionBuilder->engine(assetName_, ccy, expiryDate_, false));
    } else {
        vanilla->setPricingEngine(vanillaOptionBuilder->engine(assetName_, ccy, expiryDate_, true));
    }
    setSensitivityTemplate(*vanillaOptionBuilder);
 
    configuration = vanillaOptionBuilder->configuration(MarketContext::pricing);
    } else {
        QuantLib::ext::shared_ptr<QuantoVanillaOptionEngineBuilder> quantoVanillaOptionBuilder =
                QuantLib::ext::dynamic_pointer_cast<QuantoVanillaOptionEngineBuilder>(builder);
    QL_REQUIRE(quantoVanillaOptionBuilder != nullptr, "No (Quanto) engine builder found for trade type "
                                                                << tradeTypeBuilder);
 
    vanilla->setPricingEngine(quantoVanillaOptionBuilder->engine(assetName_, underlyingCurrency, ccy, expiryDate_));
        setSensitivityTemplate(*quantoVanillaOptionBuilder);
 
    configuration = quantoVanillaOptionBuilder->configuration(MarketContext::pricing);
    }
 
    Position::Type positionType = parsePositionType(option_.longShort());
    Real bsInd = (positionType == QuantLib::Position::Long ? 1.0 : -1.0);
    Real mult = quantity_ * bsInd;
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    maturity_ = std::max(maturity_, addPremiums(additionalInstruments, additionalMultipliers, mult,
                                                option_.premiumData(), -bsInd, ccy, engineFactory, configuration));
 
    instrument_ = QuantLib::ext::shared_ptr<InstrumentWrapper>(
        new VanillaInstrument(vanilla, mult, additionalInstruments, additionalMultipliers));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setNotionalAndCurrencies()

void setNotionalAndCurrencies ( )

Definition at line 250 of file vanillaoption.cpp.

                                                  {
    Currency ccy = parseCurrencyWithMinors(currency_);
    npvCurrency_ = ccy.code();
 
    // Notional - we really need todays spot to get the correct notional.
    // But rather than having it move around we use strike * quantity
    notional_ = strike_.value() * quantity_;
    // the following is correct for vanilla (sameCcy = true) and quanto (sameCcy = false)
    notionalCurrency_ = ccy.code();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ option()

const OptionData & option ( ) const

Definition at line 47 of file vanillaoption.hpp.

47{ return option_; }

◆ asset()

const string & asset ( ) const

Definition at line 48 of file vanillaoption.hpp.

48{ return assetName_; }

◆ currency()

const string & currency ( ) const

Definition at line 49 of file vanillaoption.hpp.

49{ return currency_; }

◆ strike()

TradeStrike strike ( ) const

Definition at line 50 of file vanillaoption.hpp.

50{ return strike_; }

◆ quantity()

double quantity ( ) const

Definition at line 51 of file vanillaoption.hpp.

51{ return quantity_; }

◆ forwardDate()

const QuantLib::Date forwardDate ( ) const

Definition at line 52 of file vanillaoption.hpp.

52{ return forwardDate_; }

◆ paymentDate()

const QuantLib::Date paymentDate ( ) const

Definition at line 53 of file vanillaoption.hpp.

53{ return paymentDate_; }

Here is the caller graph for this function:

Member Data Documentation

◆ assetClassUnderlying_

AssetClass assetClassUnderlying_

protected

Definition at line 67 of file vanillaoption.hpp.

◆ option_

OptionData option_

protected

Definition at line 68 of file vanillaoption.hpp.

◆ assetName_

string assetName_

protected

Definition at line 69 of file vanillaoption.hpp.

◆ currency_

string currency_

protected

Definition at line 70 of file vanillaoption.hpp.

◆ underlyingCurrency_

Currency underlyingCurrency_

protected

Definition at line 71 of file vanillaoption.hpp.

◆ quantity_

double quantity_

protected

Definition at line 72 of file vanillaoption.hpp.

◆ strike_

TradeStrike strike_

protected

Definition at line 73 of file vanillaoption.hpp.

◆ index_

QuantLib::ext::shared_ptr<QuantLib::Index> index_

protected

An index is needed if the option is to be automatically exercised on expiry.

Definition at line 76 of file vanillaoption.hpp.

◆ indexName_

std::string indexName_

protected

Hold the external index name if needed e.g. in the case of an FX index.

Definition at line 79 of file vanillaoption.hpp.

◆ expiryDate_

QuantLib::Date expiryDate_

protected

Store the option expiry date.

Definition at line 82 of file vanillaoption.hpp.

◆ forwardDate_

QuantLib::Date forwardDate_

protected

Store the (optional) forward date.

Definition at line 85 of file vanillaoption.hpp.

◆ paymentDate_

QuantLib::Date paymentDate_

protected

Store the (optional) payment date.

Definition at line 88 of file vanillaoption.hpp.

Public Member Functions

Inspectors

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ VanillaOptionTrade() [1/2]

◆ VanillaOptionTrade() [2/2]

Member Function Documentation

◆ build()

◆ setNotionalAndCurrencies()

◆ option()

◆ asset()

◆ currency()

◆ strike()

◆ quantity()

◆ forwardDate()

◆ paymentDate()

Member Data Documentation

◆ assetClassUnderlying_

◆ option_

◆ assetName_

◆ currency_

◆ underlyingCurrency_

◆ quantity_

◆ strike_

◆ index_

◆ indexName_

◆ expiryDate_

◆ forwardDate_

◆ paymentDate_