VarSwapEngineBuilder Class Reference

Engine Builder for Variance Swaps. More...

#include <ored/portfolio/builders/varianceswap.hpp>

Inheritance diagram for VarSwapEngineBuilder:

Collaboration diagram for VarSwapEngineBuilder:

Public Member Functions
	VarSwapEngineBuilder ()
Public Member Functions inherited from CachingEngineBuilder< T, U, Args >
	CachingEngineBuilder (const string &model, const string &engine, const set< string > &tradeTypes)
QuantLib::ext::shared_ptr< U >	engine (Args... params)
	Return a PricingEngine or a FloatingRateCouponPricer. More...
void	reset () override
	reset the builder (e.g. clear cache) More...
Public Member Functions inherited from EngineBuilder
	EngineBuilder (const string &model, const string &engine, const set< string > &tradeTypes)
virtual	~EngineBuilder ()
	Virtual destructor. More...
const string &	model () const
	Return the model name. More...
const string &	engine () const
	Return the engine name. More...
const set< string > &	tradeTypes () const
	Return the possible trade types. More...
const string &	configuration (const MarketContext &key)
	Return a configuration (or the default one if key not found) More...
virtual void	reset ()
	reset the builder (e.g. clear cache) More...
void	init (const QuantLib::ext::shared_ptr< Market > market, const map< MarketContext, string > &configurations, const map< string, string > &modelParameters, const map< string, string > &engineParameters, const std::map< std::string, std::string > &globalParameters={})
	Initialise this Builder with the market and parameters to use. More...
const set< std::pair< string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > > &	modelBuilders () const
	return model builders More...
std::string	engineParameter (const std::string &p, const std::vector< std::string > &qualifiers={}, const bool mandatory=true, const std::string &defaultValue="") const
std::string	modelParameter (const std::string &p, const std::vector< std::string > &qualifiers={}, const bool mandatory=true, const std::string &defaultValue="") const

Protected Member Functions
virtual string	keyImpl (const string &underlyingName, const Currency &ccy, const AssetClass &assetClassUnderlying, const MomentType &momentType) override
virtual QuantLib::ext::shared_ptr< PricingEngine >	engineImpl (const string &underlyingName, const Currency &ccy, const AssetClass &assetClassUnderlying, const MomentType &momentType) override
Protected Member Functions inherited from CachingEngineBuilder< T, U, Args >
virtual T	keyImpl (Args...)=0
virtual QuantLib::ext::shared_ptr< U >	engineImpl (Args...)=0

Additional Inherited Members
Protected Attributes inherited from CachingEngineBuilder< T, U, Args >
map< T, QuantLib::ext::shared_ptr< U > >	engines_
Protected Attributes inherited from EngineBuilder
string	model_
string	engine_
set< string >	tradeTypes_
QuantLib::ext::shared_ptr< Market >	market_
map< MarketContext, string >	configurations_
map< string, string >	modelParameters_
map< string, string >	engineParameters_
std::map< std::string, std::string >	globalParameters_
set< std::pair< string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > >	modelBuilders_

Detailed Description

Engine Builder for Variance Swaps.

Pricing engines are cached by equity/currency

Definition at line 53 of file varianceswap.hpp.

Constructor & Destructor Documentation

VarSwapEngineBuilder()

VarSwapEngineBuilder

(

)

Definition at line 56 of file varianceswap.hpp.

        : CachingEngineBuilder("BlackScholesMerton", "ReplicatingVarianceSwapEngine",
                               {"EquityVarianceSwap", "FxVarianceSwap", "CommodityVarianceSwap"}) {}

Member Function Documentation

keyImpl()

virtual string keyImpl ( const string &  underlyingName, const Currency &  ccy, const AssetClass &  assetClassUnderlying, const MomentType &  momentType  )

overrideprotectedvirtual

Definition at line 61 of file varianceswap.hpp.

                                                                  {
        return underlyingName + "/" + ccy.code() + "/" +
               (momentType == MomentType::Variance ? "Variance" : "Volatility");
    }

engineImpl()

virtual QuantLib::ext::shared_ptr< PricingEngine > engineImpl ( const string &  underlyingName, const Currency &  ccy, const AssetClass &  assetClassUnderlying, const MomentType &  momentType  )

overrideprotectedvirtual

Definition at line 67 of file varianceswap.hpp.

                                                                                               {
        QuantLib::ext::shared_ptr<GeneralizedBlackScholesProcess> gbsp;
        QuantLib::ext::shared_ptr<Index> index;
        if (assetClassUnderlying == AssetClass::EQ) {
            gbsp = QuantLib::ext::make_shared<GeneralizedBlackScholesProcess>(
                market_->equitySpot(underlyingName, configuration(ore::data::MarketContext::pricing)),
                market_->equityDividendCurve(underlyingName, configuration(ore::data::MarketContext::pricing)),
                market_->equityForecastCurve(underlyingName, configuration(ore::data::MarketContext::pricing)),
                market_->equityVol(underlyingName, configuration(ore::data::MarketContext::pricing)));
            index = market_->equityCurve(underlyingName).currentLink();
        } else if (assetClassUnderlying == AssetClass::FX) {
            const auto fxIndex = parseFxIndex("FX-" + underlyingName);
            const string& sourceCurrencyCode = fxIndex->sourceCurrency().code();
            const string& targetCurrencyCode = fxIndex->targetCurrency().code();
            const string& ccyPairCode = sourceCurrencyCode + targetCurrencyCode;
            gbsp = QuantLib::ext::make_shared<GeneralizedBlackScholesProcess>(
                market_->fxSpot(ccyPairCode, configuration(ore::data::MarketContext::pricing)),
                market_->discountCurve(targetCurrencyCode, configuration(ore::data::MarketContext::pricing)),
                market_->discountCurve(sourceCurrencyCode, configuration(ore::data::MarketContext::pricing)),
                market_->fxVol(ccyPairCode, configuration(ore::data::MarketContext::pricing)));
 
            index = buildFxIndex("FX-" + underlyingName, targetCurrencyCode, sourceCurrencyCode, market_,
                                 configuration(MarketContext::pricing));
         } else if (assetClassUnderlying == AssetClass::COM) {
            Handle<BlackVolTermStructure> vol = market_->commodityVolatility(underlyingName, configuration(ore::data::MarketContext::pricing));
            Handle<QuantExt::PriceTermStructure> priceCurve = market_->commodityPriceCurve(underlyingName, configuration(ore::data::MarketContext::pricing));
            Handle<Quote> commoditySpot(QuantLib::ext::make_shared<QuantExt::DerivedPriceQuote>(priceCurve));
            Handle<YieldTermStructure> discount = market_->discountCurve(ccy.code(), configuration(ore::data::MarketContext::pricing));
            Handle<YieldTermStructure> yield(QuantLib::ext::make_shared<QuantExt::PriceTermStructureAdapter>(*priceCurve, *discount));
            yield->enableExtrapolation();
            gbsp = QuantLib::ext::make_shared<GeneralizedBlackScholesProcess>(commoditySpot, yield, discount, vol);
            index = market_->commodityIndex(underlyingName).currentLink();
        } else {
            QL_FAIL("Asset class of " + underlyingName + " not recognized.");
        }
 
        QuantExt::GeneralisedReplicatingVarianceSwapEngine::VarSwapSettings settings;
 
        std::string schemeStr = engineParameter("Scheme", {}, false, "GaussLobatto");
        std::string boundsStr = engineParameter("Bounds", {}, false, "PriceThreshold");
 
        if (schemeStr == "GaussLobatto")
            settings.scheme = QuantExt::GeneralisedReplicatingVarianceSwapEngine::VarSwapSettings::Scheme::GaussLobatto;
        else if (schemeStr == "Segment")
            settings.scheme = QuantExt::GeneralisedReplicatingVarianceSwapEngine::VarSwapSettings::Scheme::Segment;
        else {
            QL_FAIL("invalid var swap pricing engine parameter Scheme (" << schemeStr
                                                                         << "), expected GaussLobatto, Segment");
        }
 
        if (boundsStr == "Fixed")
            settings.bounds = QuantExt::GeneralisedReplicatingVarianceSwapEngine::VarSwapSettings::Bounds::Fixed;
        else if (boundsStr == "PriceThreshold")
            settings.bounds = QuantExt::GeneralisedReplicatingVarianceSwapEngine::VarSwapSettings::Bounds::PriceThreshold;
        else {
            QL_FAIL("invalid var swap pricing engine parameter Bounds (" << boundsStr
                                                                         << "), expected Fixed, PriceThreshold");
        }
 
        settings.accuracy = parseReal(engineParameter("Accuracy", {}, false, "1E-5"));
        settings.maxIterations = parseInteger(engineParameter("MaxIterations", {}, false, "1000"));
        settings.steps = parseInteger(engineParameter("Steps", {}, false, "100"));
        settings.priceThreshold = parseReal(engineParameter("PriceThreshold", {}, false, "1E-10"));
        settings.maxPriceThresholdSteps = parseInteger(engineParameter("MaxPriceThresholdSteps", {}, false, "100"));
        settings.priceThresholdStep = parseReal(engineParameter("PriceThresholdStep", {}, false, "0.1"));
        settings.fixedMinStdDevs = parseReal(engineParameter("FixedMinStdDevs", {}, false, "-5.0"));
        settings.fixedMaxStdDevs = parseReal(engineParameter("FixedMaxStdDevs", {}, false, "5.0"));
 
        bool staticTodaysSpot = false;
        if (auto it = globalParameters_.find("RunType");
            it != globalParameters_.end() && it->second != "Exposure") {
            staticTodaysSpot = parseBool(modelParameter("StaticTodaysSpot", {}, false, "false"));
        }
 
        if (momentType == MomentType::Variance)
            return QuantLib::ext::make_shared<QuantExt::GeneralisedReplicatingVarianceSwapEngine>(
                index, gbsp, market_->discountCurve(ccy.code(), configuration(ore::data::MarketContext::pricing)),
                settings, staticTodaysSpot);
        else
            return QuantLib::ext::make_shared<QuantExt::VolatilityFromVarianceSwapEngine>(
                index, gbsp, market_->discountCurve(ccy.code(), configuration(ore::data::MarketContext::pricing)),
                settings, staticTodaysSpot);
    }

Here is the call graph for this function: