Serializable FX Barrier Option. More...

#include <ored/portfolio/barrieroption.hpp>

Inheritance diagram for BarrierOption:

Collaboration diagram for BarrierOption:

Public Member Functions
	BarrierOption ()
	Constructor. More...

	BarrierOption (ore::data::OptionData option, BarrierData barrier, QuantLib::Date startDate=QuantLib::Date(), const std::string &calendar=std::string())

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

virtual void	checkBarriers ()=0
	check validity of barriers More...

virtual QuantLib::ext::shared_ptr< QuantLib::Index >	getIndex ()=0

virtual const QuantLib::Real	strike ()=0

virtual QuantLib::Real	tradeMultiplier ()=0

virtual Currency	tradeCurrency ()=0

virtual QuantLib::ext::shared_ptr< QuantLib::PricingEngine >	vanillaPricingEngine (const QuantLib::ext::shared_ptr< EngineFactory > &ef, const QuantLib::Date &expiryDate, const QuantLib::Date &paymentDate)=0

virtual QuantLib::ext::shared_ptr< QuantLib::PricingEngine >	barrierPricingEngine (const QuantLib::ext::shared_ptr< EngineFactory > &ef, const QuantLib::Date &expiryDate, const QuantLib::Date &paymentDate)=0

virtual const QuantLib::Handle< QuantLib::Quote > &	spotQuote ()=0

virtual void	additionalFromXml (ore::data::XMLNode *node)=0

virtual void	additionalToXml (ore::data::XMLDocument &doc, ore::data::XMLNode *node) const =0

virtual std::string	indexFixingName ()=0

Inspectors
const ore::data::OptionData &	option () const

const BarrierData &	barrier () const

const QuantLib::Date &	startDate () const

const QuantLib::Calendar &	calendar () const

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

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

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

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

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

const RequiredFixings &	requiredFixings () const

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

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

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

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

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

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

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

const string &	id () const

const string &	tradeType () const

const Envelope &	envelope () const

const set< string > &	portfolioIds () const

const TradeActions &	tradeActions () const

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

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

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

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

const string &	npvCurrency () const

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

Serialisation
ore::data::OptionData	option_

BarrierData	barrier_

QuantLib::Date	startDate_

QuantLib::Calendar	calendar_

std::string	calendarStr_

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

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

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 FX Barrier Option.

Definition at line 40 of file barrieroption.hpp.

Constructor & Destructor Documentation

◆ BarrierOption() [1/2]

BarrierOption ( )

Constructor.

Definition at line 43 of file barrieroption.hpp.

43{}

◆ BarrierOption() [2/2]

BarrierOption	(	ore::data::OptionData	option,
		BarrierData	barrier,
		QuantLib::Date	startDate = `QuantLib::Date()`,
		const std::string &	calendar = `std::string()`
	)

Definition at line 45 of file barrieroption.hpp.

        : option_(option), barrier_(barrier), startDate_(startDate), calendarStr_(calendar) {
        calendar_ = parseCalendar(calendarStr_);
    }

Here is the call graph for this function:

Member Function Documentation

◆ build()

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

override

Build QuantLib/QuantExt instrument, link pricing engine.

Definition at line 46 of file barrieroption.cpp.

                                                                                   { 
    QL_REQUIRE(tradeActions().empty(), "TradeActions not supported for FxBarrierOption");
 
    checkBarriers();
 
    QL_REQUIRE(barrier_.levels().size() > 0 && barrier_.levels().size() <= 2, "BarrierOption must have 1 or 2 levels");
    QL_REQUIRE(option_.style() == "European", "Option Style unknown: " << option_.style());
    QL_REQUIRE(option_.exerciseDates().size() == 1, "Invalid number of exercise dates");
        
    // get the expiry date
    Date expiryDate = parseDate(option_.exerciseDates().front());
    Date payDate = expiryDate;
    const boost::optional<OptionPaymentData>& opd = option_.paymentData();
    if (opd) {
        if (opd->rulesBased()) {
            Calendar payCalendar = opd->calendar();
            payDate = payCalendar.advance(expiryDate, opd->lag(), Days, opd->convention());
        } else {
            if (opd->dates().size() > 1)
                ore::data::StructuredTradeWarningMessage(id(), tradeType(), "Trade build",
                                                         "Found more than 1 payment date. The first one will be used.")
                    .log();
            payDate = opd->dates().front();
        }
    }
    QL_REQUIRE(payDate >= expiryDate, "Settlement date cannot be earlier than expiry date");
 
    Real rebate = barrier_.rebate() / tradeMultiplier();
    QL_REQUIRE(rebate >= 0, "rebate must be non-negative");
 
    
    // set the maturity
    maturity_ = std::max(option_.premiumData().latestPremiumDate(), payDate);
 
    // fx base
    // Payoff
    Option::Type type = parseOptionType(option_.callPut());
    QuantLib::ext::shared_ptr<StrikedTypePayoff> payoff(new PlainVanillaPayoff(type, strike()));
 
    QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(expiryDate);
    // QL does not have an FXBarrierOption, so we add a barrier option and a vanilla option here and wrap
    // it in a composite to get the notional in.
 
    std::vector<QuantLib::ext::shared_ptr<Instrument>> additionalInstruments;
    std::vector<Real> additionalMultipliers;
    Settlement::Type settleType = parseSettlementType(option_.settlement());
    Position::Type positionType = parsePositionType(option_.longShort());
 
    QuantLib::ext::shared_ptr<Instrument> vanilla;
    QuantLib::ext::shared_ptr<Instrument> barrier;
    QuantLib::ext::shared_ptr<InstrumentWrapper> instWrapper;
 
    bool exercised = false;
    Real exercisePrice = Null<Real>();
 
    if (payDate > expiryDate) {
        // Has the option been marked as exercised
        const boost::optional<OptionExerciseData>& oed = option_.exerciseData();
        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();
        }
 
        QuantLib::ext::shared_ptr<Index> index;
        if (option_.isAutomaticExercise()) {
            index = getIndex();
            QL_REQUIRE(index, "Barrier option trade with delayed payment "
                                  << id() << ": the FXIndex node needs to be populated.");
            requiredFixings_.addFixingDate(expiryDate, index->name(), payDate);
        }
        vanilla = QuantLib::ext::make_shared<CashSettledEuropeanOption>(payoff->optionType(), payoff->strike(), expiryDate,
                                                                payDate, option_.isAutomaticExercise(), index,
                                                                exercised, exercisePrice);
    } else {
        vanilla = QuantLib::ext::make_shared<VanillaOption>(payoff, exercise);
    }
    
    boost::variant<Barrier::Type, DoubleBarrier::Type> barrierType;
    if (barrier_.levels().size() < 2) {
        barrierType = parseBarrierType(barrier_.type());
        barrier = QuantLib::ext::make_shared<QuantLib::BarrierOption>(QuantLib::ext::get<Barrier::Type>(barrierType), barrier_.levels()[0].value(), 
            rebate, payoff, exercise);
    } else {
        barrierType = parseDoubleBarrierType(barrier_.type());
        barrier = QuantLib::ext::make_shared<QuantLib::DoubleBarrierOption>(QuantLib::ext::get<DoubleBarrier::Type>(barrierType),
            barrier_.levels()[0].value(), barrier_.levels()[1].value(), rebate, payoff, exercise);
    }
 
    QuantLib::ext::shared_ptr<QuantLib::PricingEngine> barrierEngine = barrierPricingEngine(engineFactory, expiryDate, payDate);
    QuantLib::ext::shared_ptr<QuantLib::PricingEngine> vanillaEngine = vanillaPricingEngine(engineFactory, expiryDate, payDate);
   
    // set pricing engines
    barrier->setPricingEngine(barrierEngine);
    vanilla->setPricingEngine(vanillaEngine);
 
    QuantLib::ext::shared_ptr<QuantLib::Index> index = getIndex();
    const QuantLib::Handle<QuantLib::Quote>& spot = spotQuote();
    if (barrier_.levels().size() < 2)
        instWrapper = QuantLib::ext::make_shared<SingleBarrierOptionWrapper>(
            barrier, positionType == Position::Long ? true : false, expiryDate,
            settleType == Settlement::Physical ? true : false, vanilla, QuantLib::ext::get<Barrier::Type>(barrierType),
            spot, barrier_.levels()[0].value(), rebate, tradeCurrency(), startDate_, index, calendar_,
            tradeMultiplier(), tradeMultiplier(), additionalInstruments, additionalMultipliers);
    else
        instWrapper = QuantLib::ext::make_shared<DoubleBarrierOptionWrapper>(
            barrier, positionType == Position::Long ? true : false, expiryDate,
            settleType == Settlement::Physical ? true : false, vanilla, QuantLib::ext::get<DoubleBarrier::Type>(barrierType),
            spot, barrier_.levels()[0].value(), barrier_.levels()[1].value(), rebate, tradeCurrency(), startDate_, index, calendar_,
            tradeMultiplier(), tradeMultiplier(), additionalInstruments, additionalMultipliers);
 
    instrument_ = instWrapper;
 
    Calendar fixingCal = index ? index->fixingCalendar() : calendar_;
    if (startDate_ != Null<Date>() && !indexFixingName().empty()) {
        for (Date d = fixingCal.adjust(startDate_); d <= expiryDate; d = fixingCal.advance(d, 1 * Days)) {
            requiredFixings_.addFixingDate(d, indexFixingName(), payDate);
        }
    }
 
    // Add additional premium payments
    Real bsInd = (positionType == QuantLib::Position::Long ? 1.0 : -1.0);
    addPremiums(additionalInstruments, additionalMultipliers, bsInd * tradeMultiplier(), option_.premiumData(), -bsInd,
                tradeCurrency(), engineFactory, engineFactory->configuration(MarketContext::pricing));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkBarriers()

virtual void checkBarriers ( )

pure virtual

check validity of barriers

Implemented in EquityBarrierOption, EquityDoubleBarrierOption, FxBarrierOption, and FxDoubleBarrierOption.

Here is the caller graph for this function:

◆ getIndex()

virtual QuantLib::ext::shared_ptr< QuantLib::Index > getIndex ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ strike()

virtual const QuantLib::Real strike ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ tradeMultiplier()

virtual QuantLib::Real tradeMultiplier ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ tradeCurrency()

virtual Currency tradeCurrency ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ vanillaPricingEngine()

virtual QuantLib::ext::shared_ptr< QuantLib::PricingEngine > vanillaPricingEngine	(	const QuantLib::ext::shared_ptr< EngineFactory > &	ef,
		const QuantLib::Date &	expiryDate,
		const QuantLib::Date &	paymentDate
	)

pure virtual

Implemented in EquityBarrierOption, EquityDoubleBarrierOption, FxBarrierOption, and FxDoubleBarrierOption.

Here is the caller graph for this function:

◆ barrierPricingEngine()

virtual QuantLib::ext::shared_ptr< QuantLib::PricingEngine > barrierPricingEngine	(	const QuantLib::ext::shared_ptr< EngineFactory > &	ef,
		const QuantLib::Date &	expiryDate,
		const QuantLib::Date &	paymentDate
	)

pure virtual

Implemented in EquityDoubleBarrierOption, EquityBarrierOption, FxBarrierOption, and FxDoubleBarrierOption.

Here is the caller graph for this function:

◆ spotQuote()

virtual const QuantLib::Handle< QuantLib::Quote > & spotQuote ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ additionalFromXml()

virtual void additionalFromXml ( ore::data::XMLNode * node )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ additionalToXml()

virtual void additionalToXml	(	ore::data::XMLDocument &	doc,
		ore::data::XMLNode *	node
	)		const

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ indexFixingName()

virtual std::string indexFixingName ( )

pure virtual

Implemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Here is the caller graph for this function:

◆ option()

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

Definition at line 79 of file barrieroption.hpp.

79{ return option_; }

Here is the caller graph for this function:

◆ barrier()

const BarrierData & barrier ( ) const

Definition at line 80 of file barrieroption.hpp.

80{ return barrier_; }

Here is the caller graph for this function:

◆ startDate()

const QuantLib::Date & startDate ( ) const

Definition at line 81 of file barrieroption.hpp.

81{ return startDate_; }

◆ calendar()

const QuantLib::Calendar & calendar ( ) const

Definition at line 82 of file barrieroption.hpp.

82{ return calendar_; }

◆ fromXML()

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

overridevirtual

Reimplemented from Trade.

Reimplemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Definition at line 176 of file barrieroption.cpp.

                                         {
    Trade::fromXML(node);
    XMLNode* dataNode = XMLUtils::getChildNode(node, tradeType_ + "Data");
    QL_REQUIRE(dataNode, "No " + tradeType_ + " Node");
    option_.fromXML(XMLUtils::getChildNode(dataNode, "OptionData"));
    barrier_.fromXML(XMLUtils::getChildNode(dataNode, "BarrierData"));
    startDate_ = ore::data::parseDate(XMLUtils::getChildValue(dataNode, "StartDate", false));
    calendarStr_ = XMLUtils::getChildValue(dataNode, "Calendar", false);
    calendar_ = parseCalendar(calendarStr_);
 
    additionalFromXml(dataNode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toXML()

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

overridevirtual

Reimplemented from Trade.

Reimplemented in FxOptionWithBarrier, and EquityOptionWithBarrier.

Definition at line 189 of file barrieroption.cpp.

                                                    {
    XMLNode* node = Trade::toXML(doc);
    XMLNode* barNode = doc.allocNode(tradeType_ + "Data");
    XMLUtils::appendNode(node, barNode);
 
    XMLUtils::appendNode(barNode, option_.toXML(doc));
    XMLUtils::appendNode(barNode, barrier_.toXML(doc));
    if (startDate_ != Date())
        XMLUtils::addChild(doc, barNode, "StartDate", to_string(startDate_));
    if (!calendarStr_.empty())
        XMLUtils::addChild(doc, barNode, "Calendar", calendarStr_);
    additionalToXml(doc, barNode);
 
    return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ option_

ore::data::OptionData option_

private

Definition at line 92 of file barrieroption.hpp.

◆ barrier_

BarrierData barrier_

private

Definition at line 93 of file barrieroption.hpp.

◆ startDate_

QuantLib::Date startDate_

private

Definition at line 94 of file barrieroption.hpp.

◆ calendar_

QuantLib::Calendar calendar_

private

Definition at line 95 of file barrieroption.hpp.

◆ calendarStr_

std::string calendarStr_

protected

Definition at line 98 of file barrieroption.hpp.

Public Member Functions

Serialisation

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BarrierOption() [1/2]

◆ BarrierOption() [2/2]

Member Function Documentation

◆ build()

◆ checkBarriers()

◆ getIndex()

◆ strike()

◆ tradeMultiplier()

◆ tradeCurrency()

◆ vanillaPricingEngine()

◆ barrierPricingEngine()

◆ spotQuote()

◆ additionalFromXml()

◆ additionalToXml()

◆ indexFixingName()

◆ option()

◆ barrier()

◆ startDate()

◆ calendar()

◆ fromXML()

◆ toXML()

Member Data Documentation

◆ option_

◆ barrier_

◆ startDate_

◆ calendar_

◆ calendarStr_