EquityVolCurve Class Reference

Wrapper class for building Equity volatility structures. More...

#include <ored/marketdata/equityvolcurve.hpp>

Collaboration diagram for EquityVolCurve:

Public Member Functions
Constructors
	EquityVolCurve ()
	Default constructor. More...
	EquityVolCurve (Date asof, EquityVolatilityCurveSpec spec, const Loader &loader, const CurveConfigurations &curveConfigs, const QuantLib::Handle< QuantExt::EquityIndex2 > &eqIndex, const std::map< std::string, QuantLib::ext::shared_ptr< EquityCurve > > &requiredEquityCurves={}, const std::map< std::string, QuantLib::ext::shared_ptr< EquityVolCurve > > &requiredEquityVolCurves={}, const std::map< std::string, QuantLib::ext::shared_ptr< FXVolCurve > > &requiredFxVolCurves={}, const std::map< std::string, QuantLib::ext::shared_ptr< CorrelationCurve > > &requiredCorrelationCurves={}, const Market *market=nullptr, const bool buildCalibrationInfo=true)
	Detailed constructor. More...

Inspectors
EquityVolatilityCurveSpec	spec_
QuantLib::ext::shared_ptr< BlackVolTermStructure >	vol_
QuantLib::Calendar	calendar_
QuantLib::Currency	currency_
QuantLib::DayCounter	dayCounter_
QuantLib::Date	maxExpiry_
QuantLib::ext::shared_ptr< VolatilityConfig >	volatilityConfig_
QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo >	calibrationInfo_
const EquityVolatilityCurveSpec &	spec () const
void	buildVolatility (const QuantLib::Date &asof, const EquityVolatilityCurveConfig &vc, const ConstantVolatilityConfig &cvc, const Loader &loader)
	Build a volatility structure from a single constant volatility quote. More...
void	buildVolatility (const QuantLib::Date &asof, const EquityVolatilityCurveConfig &vc, const VolatilityCurveConfig &vcc, const Loader &loader)
	Build a volatility curve from a 1-D curve of volatility quotes. More...
void	buildVolatility (const QuantLib::Date &asof, EquityVolatilityCurveConfig &vc, const VolatilityStrikeSurfaceConfig &vssc, const Loader &loader, const QuantLib::Handle< QuantExt::EquityIndex2 > &eqIndex)
	Build a volatility surface from a collection of expiry and absolute strike pairs. More...
void	buildVolatility (const QuantLib::Date &asof, EquityVolatilityCurveConfig &vc, const VolatilityMoneynessSurfaceConfig &vmsc, const Loader &loader, const QuantLib::Handle< QuantExt::EquityIndex2 > &eqIndex)
	Build a volatility surface from a collection of expiry and moneyness strike pairs. More...
void	buildVolatility (const QuantLib::Date &asof, EquityVolatilityCurveConfig &vc, const VolatilityDeltaSurfaceConfig &vdsc, const Loader &loader, const QuantLib::Handle< QuantExt::EquityIndex2 > &eqIndex)
	Build a volatility surface from a collection of expiry and strike delta pairs. More...
void	buildVolatility (const QuantLib::Date &asof, const EquityVolatilityCurveSpec &spec, const CurveConfigurations &curveConfigs, const ProxyVolatilityConfig &epvc, const map< string, QuantLib::ext::shared_ptr< EquityCurve > > &eqCurves, const map< string, QuantLib::ext::shared_ptr< EquityVolCurve > > &eqVolCurves, const map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &fxVolCurves, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &requiredCorrelationCurves, const Market *fxIndices=nullptr)
	Build a volatility surface as a proxy from another volatility surface. More...
void	buildCalibrationInfo (const QuantLib::Date &asof, const CurveConfigurations &curveConfigs, const EquityVolatilityCurveConfig &config, const Handle< QuantExt::EquityIndex2 > &eqIndex)
	Build the calibration info. More...
const QuantLib::ext::shared_ptr< BlackVolTermStructure > &	volTermStructure () const
const QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo > &	calibrationInfo () const

Detailed Description

Wrapper class for building Equity volatility structures.

Definition at line 44 of file equityvolcurve.hpp.

Constructor & Destructor Documentation

EquityVolCurve() [1/2]

EquityVolCurve

(

)

Default constructor.

Definition at line 49 of file equityvolcurve.hpp.

{}

EquityVolCurve() [2/2]

EquityVolCurve	(	Date	asof,
		EquityVolatilityCurveSpec	spec,
		const Loader &	loader,
		const CurveConfigurations &	curveConfigs,
		const QuantLib::Handle< QuantExt::EquityIndex2 > &	eqIndex,
		const std::map< std::string, QuantLib::ext::shared_ptr< EquityCurve > > &	requiredEquityCurves = {},
		const std::map< std::string, QuantLib::ext::shared_ptr< EquityVolCurve > > &	requiredEquityVolCurves = {},
		const std::map< std::string, QuantLib::ext::shared_ptr< FXVolCurve > > &	requiredFxVolCurves = {},
		const std::map< std::string, QuantLib::ext::shared_ptr< CorrelationCurve > > &	requiredCorrelationCurves = {},
		const Market *	market = nullptr,
		const bool	buildCalibrationInfo = true
	)

Detailed constructor.

Member Function Documentation

spec()

const EquityVolatilityCurveSpec & spec

(

)

const

Definition at line 62 of file equityvolcurve.hpp.

{ return spec_; }

Here is the caller graph for this function:

buildVolatility() [1/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		const EquityVolatilityCurveConfig &	vc,
		const ConstantVolatilityConfig &	cvc,
		const Loader &	loader
	)

Build a volatility structure from a single constant volatility quote.

buildVolatility() [2/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		const EquityVolatilityCurveConfig &	vc,
		const VolatilityCurveConfig &	vcc,
		const Loader &	loader
	)

Build a volatility curve from a 1-D curve of volatility quotes.

buildVolatility() [3/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		EquityVolatilityCurveConfig &	vc,
		const VolatilityStrikeSurfaceConfig &	vssc,
		const Loader &	loader,
		const QuantLib::Handle< QuantExt::EquityIndex2 > &	eqIndex
	)

Build a volatility surface from a collection of expiry and absolute strike pairs.

buildVolatility() [4/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		EquityVolatilityCurveConfig &	vc,
		const VolatilityMoneynessSurfaceConfig &	vmsc,
		const Loader &	loader,
		const QuantLib::Handle< QuantExt::EquityIndex2 > &	eqIndex
	)

Build a volatility surface from a collection of expiry and moneyness strike pairs.

buildVolatility() [5/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		EquityVolatilityCurveConfig &	vc,
		const VolatilityDeltaSurfaceConfig &	vdsc,
		const Loader &	loader,
		const QuantLib::Handle< QuantExt::EquityIndex2 > &	eqIndex
	)

Build a volatility surface from a collection of expiry and strike delta pairs.

Definition at line 768 of file equityvolcurve.cpp.

                                                                                          {
 
    using boost::adaptors::transformed;
    using boost::algorithm::join;
 
    DLOG("EquityVolCurve: start building 2-D volatility delta strike surface");
 
    QL_REQUIRE(vdsc.quoteType() == MarketDatum::QuoteType::RATE_LNVOL,
               "EquityVolCurve: only quote type"
                   << " RATE_LNVOL is currently supported for a 2-D volatility delta strike surface.");
 
    // Parse, sort and check the vector of configured put deltas
    vector<Real> putDeltas = parseVectorOfValues<Real>(vdsc.putDeltas(), &parseReal);
    sort(putDeltas.begin(), putDeltas.end(), [](Real x, Real y) { return !close(x, y) && x < y; });
    QL_REQUIRE(adjacent_find(putDeltas.begin(), putDeltas.end(), [](Real x, Real y) { return close(x, y); }) ==
                   putDeltas.end(),
               "EquityVolCurve: The configured put deltas contain duplicates");
    DLOG("EquityVolCurve: Parsed " << putDeltas.size() << " unique configured put deltas");
    DLOG("EquityVolCurve: Put deltas are: " << join(putDeltas | transformed([](Real d) { return ore::data::to_string(d); }), ","));
 
    // Parse, sort descending and check the vector of configured call deltas
    vector<Real> callDeltas = parseVectorOfValues<Real>(vdsc.callDeltas(), &parseReal);
    sort(callDeltas.begin(), callDeltas.end(), [](Real x, Real y) { return !close(x, y) && x > y; });
    QL_REQUIRE(adjacent_find(callDeltas.begin(), callDeltas.end(), [](Real x, Real y) { return close(x, y); }) ==
                   callDeltas.end(),
               "EquityVolCurve: The configured call deltas contain duplicates");
    DLOG("EquityVolCurve: Parsed " << callDeltas.size() << " unique configured call deltas");
    DLOG("EquityVolCurve: Call deltas are: " << join(callDeltas | transformed([](Real d) { return ore::data::to_string(d); }), ","));
 
    // Expiries may be configured with a wildcard or given explicitly
    bool expWc = false;
    if (find(vdsc.expiries().begin(), vdsc.expiries().end(), "*") != vdsc.expiries().end()) {
        expWc = true;
        QL_REQUIRE(vdsc.expiries().size() == 1, "Wild card expiry specified but more expiries also specified.");
        DLOG("EquityVolCurve: Have expiry wildcard pattern " << vdsc.expiries()[0]);
    }
 
    // Map to hold the rows of the equity volatility matrix. The keys are the expiry dates and the values are the
    // vectors of volatilities, one for each configured delta.
    map<Date, vector<Real>> surfaceData;
 
    // Number of strikes = number of put deltas + ATM + number of call deltas
    Size numStrikes = putDeltas.size() + 1 + callDeltas.size();
 
    // Count the number of quotes added. We check at the end that we have added all configured quotes.
    Size quotesAdded = 0;
 
    // Configured delta and Atm types.
    DeltaVolQuote::DeltaType deltaType = parseDeltaType(vdsc.deltaType());
    DeltaVolQuote::AtmType atmType = parseAtmType(vdsc.atmType());
    boost::optional<DeltaVolQuote::DeltaType> atmDeltaType;
    if (!vdsc.atmDeltaType().empty()) {
        atmDeltaType = parseDeltaType(vdsc.atmDeltaType());
    }
 
    // Populate the configured strikes.
    vector<QuantLib::ext::shared_ptr<BaseStrike>> strikes;
    for (const auto& pd : putDeltas) {
        strikes.push_back(QuantLib::ext::make_shared<DeltaStrike>(deltaType, Option::Put, pd));
    }
    strikes.push_back(QuantLib::ext::make_shared<AtmStrike>(atmType, atmDeltaType));
    for (const auto& cd : callDeltas) {
        strikes.push_back(QuantLib::ext::make_shared<DeltaStrike>(deltaType, Option::Call, cd));
    }
 
    // Read the quotes to fill the expiry dates and vols matrix.
    std::ostringstream ss;
    ss << MarketDatum::InstrumentType::EQUITY_OPTION << "/" << vdsc.quoteType() << "/" << vc.equityId() << "/"
       << vc.ccy() << "/*";
    Wildcard w(ss.str());
    for (const auto& md : loader.get(w, asof)) {
 
        QL_REQUIRE(md->asofDate() == asof, "MarketDatum asofDate '" << md->asofDate() << "' <> asof '" << asof << "'");
 
        auto q = QuantLib::ext::dynamic_pointer_cast<EquityOptionQuote>(md);
        QL_REQUIRE(q, "Internal error: could not downcast MarketDatum '" << md->name() << "' to EquityOptionQuote");
        QL_REQUIRE(q->eqName() == vc.equityId(), "EquityOptionQuote eqName '"
                                                     << q->eqName() << "' <> EquityVolatilityCurveConfig equityId '"
                                                     << vc.equityId() << "'");
        QL_REQUIRE(q->ccy() == vc.ccy(),
            "EquityOptionQuote ccy '" << q->ccy() << "' <> EquityVolatilityCurveConfig ccy '" << vc.ccy() << "'");
        QL_REQUIRE(q->quoteType() == vdsc.quoteType(),
            "EquityOptionQuote quoteType '" << q->quoteType() << "' <> VolatilityMoneynessSurfaceConfig quoteType '" << vdsc.quoteType() << "'");
 
        // Iterator to one of the configured strikes.
        vector<QuantLib::ext::shared_ptr<BaseStrike>>::iterator strikeIt;
 
        if (expWc) {
            // Check if quote's strike is in the configured strikes and continue if it is not.
            strikeIt = find_if(strikes.begin(), strikes.end(),
                               [&q](QuantLib::ext::shared_ptr<BaseStrike> s) { return *s == *q->strike(); });
            if (strikeIt == strikes.end())
                continue;
        } else {
            // If we have explicitly configured expiries and the quote is not in the configured quotes continue.
            auto it = find(vc.quotes().begin(), vc.quotes().end(), q->name());
            if (it == vc.quotes().end())
                continue;
 
            // Check if quote's strike is in the configured strikes.
            // It should be as we have selected from the explicitly configured quotes in the last step.
            strikeIt = find_if(strikes.begin(), strikes.end(),
                               [&q](QuantLib::ext::shared_ptr<BaseStrike> s) { return *s == *q->strike(); });
            QL_REQUIRE(strikeIt != strikes.end(),
                       "EquityVolCurve: The quote '"
                           << q->name()
                           << "' is in the list of configured quotes but does not match any of the configured strikes");
        }
 
        // Position of quote in vector of strikes
        Size pos = std::distance(strikes.begin(), strikeIt);
 
        // Process the quote
        Date eDate;
        QuantLib::ext::shared_ptr<Expiry> expiry = parseExpiry(q->expiry());
        if (auto expiryDate = QuantLib::ext::dynamic_pointer_cast<ExpiryDate>(expiry)) {
            eDate = expiryDate->expiryDate();
        } else if (auto expiryPeriod = QuantLib::ext::dynamic_pointer_cast<ExpiryPeriod>(expiry)) {
            // We may need more conventions here eventually.
            eDate = calendar_.adjust(asof + expiryPeriod->expiryPeriod());
        }
 
        // Add quote to surface
        if (surfaceData.count(eDate) == 0)
            surfaceData[eDate] = vector<Real>(numStrikes, Null<Real>());
 
        QL_REQUIRE(surfaceData[eDate][pos] == Null<Real>(),
                   "EquityVolCurve: Quote " << q->name() << " provides a duplicate quote for the date " << io::iso_date(eDate)
                            << " and strike " << *q->strike());
        surfaceData[eDate][pos] = q->quote()->value();
        quotesAdded++;
 
        TLOG("EquityVolCurve: Added quote " << q->name() << ": (" << io::iso_date(eDate) << "," << *q->strike() << "," << fixed
                            << setprecision(9) << "," << q->quote()->value() << ")");
    }
 
    DLOG("EquityVolCurve: EquityVolCurve: added " << quotesAdded << " quotes in building delta strike surface.");
 
    // Check the data gathered.
    if (expWc) {
        // If the expiries were configured via a wildcard, check that no surfaceData element has a Null<Real>().
        for (const auto& kv : surfaceData) {
            for (Size j = 0; j < numStrikes; j++) {
                QL_REQUIRE(kv.second[j] != Null<Real>(), "EquityVolCurve: Volatility for expiry date "
                                                             << io::iso_date(kv.first) << " and strike " << *strikes[j]
                                                             << " not found. Cannot proceed with a sparse matrix.");
            }
        }
    } else {
        // If expiries were configured explicitly, the number of configured quotes should equal the
        // number of quotes added.
        QL_REQUIRE(vc.quotes().size() == quotesAdded,
                   "EquityVolCurve: Found " << quotesAdded << " quotes, but " << vc.quotes().size() << " quotes required by config.");
    }
 
    // Populate the matrix of volatilities and the expiry dates.
    vector<Date> expiryDates;
    Matrix vols(surfaceData.size(), numStrikes);
    for (const auto row : surfaceData | boost::adaptors::indexed(0)) {
        expiryDates.push_back(row.value().first);
        copy(row.value().second.begin(), row.value().second.end(), vols.row_begin(row.index()));
    }
 
    // Need to multiply each put delta value by -1 before passing it to the BlackVolatilitySurfaceDelta ctor
    // i.e. a put delta of 0.25 that is passed in to the config must be -0.25 when passed to the ctor.
    transform(putDeltas.begin(), putDeltas.end(), putDeltas.begin(), [](Real pd) { return -1.0 * pd; });
    DLOG("EquityVolCurve: Multiply put deltas by -1.0 before creating BlackVolatilitySurfaceDelta object.");
    DLOG("EquityVolCurve: Put deltas are: " << join(putDeltas | transformed([](Real d) { return ore::data::to_string(d); }), ","));
 
    // Set the strike extrapolation which only matters if extrapolation is turned on for the whole surface.
    // BlackVolatilitySurfaceDelta time extrapolation is hard-coded to constant in volatility.
    bool flatExtrapolation = true;
    if (vdsc.extrapolation()) {
 
        auto strikeExtrapType = parseExtrapolation(vdsc.strikeExtrapolation());
        if (strikeExtrapType == Extrapolation::UseInterpolator) {
            TLOG("EquityVolCurve: Strike extrapolation switched to using interpolator.");
            flatExtrapolation = false;
        } else if (strikeExtrapType == Extrapolation::None) {
            TLOG("EquityVolCurve: Strike extrapolation cannot be turned off on its own so defaulting to flat.");
        } else if (strikeExtrapType == Extrapolation::Flat) {
            TLOG("EquityVolCurve: Strike extrapolation has been set to flat.");
        } else {
            TLOG("EquityVolCurve: Strike extrapolation " << strikeExtrapType << " not expected so default to flat.");
        }
 
        auto timeExtrapType = parseExtrapolation(vdsc.timeExtrapolation());
        if (timeExtrapType != Extrapolation::Flat) {
            TLOG("EquityVolCurve: BlackVolatilitySurfaceDelta only supports flat volatility extrapolation in the time direction");
        }
    } else {
        TLOG("EquityVolCurve: Extrapolation is turned off for the whole surface so the time and"
             << " strike extrapolation settings are ignored");
    }
 
    // Time interpolation
    if (vdsc.timeInterpolation() != "Linear") {
        TLOG("EquityVolCurve: BlackVolatilitySurfaceDelta only supports linear time interpolation.");
    }
 
    // Strike interpolation
    InterpolatedSmileSection::InterpolationMethod im;
    if (vdsc.strikeInterpolation() == "Linear") {
        im = InterpolatedSmileSection::InterpolationMethod::Linear;
    } else if (vdsc.strikeInterpolation() == "NaturalCubic") {
        im = InterpolatedSmileSection::InterpolationMethod::NaturalCubic;
    } else if (vdsc.strikeInterpolation() == "FinancialCubic") {
        im = InterpolatedSmileSection::InterpolationMethod::FinancialCubic;
    } else if (vdsc.strikeInterpolation() == "CubicSpline") {
        im = InterpolatedSmileSection::InterpolationMethod::CubicSpline;
    } else {
        im = InterpolatedSmileSection::InterpolationMethod::Linear;
        DLOG("EquityVolCurve: BlackVolatilitySurfaceDelta does not support strike interpolation '" << vdsc.strikeInterpolation()
                                                                                   << "' so setting it to linear.");
    }
 
    // set max expiry date (used in buildCalibrationInfo())
    if (!expiryDates.empty())
        maxExpiry_ = expiryDates.back();
 
    DLOG("EquityVolCurve: Creating BlackVolatilitySurfaceDelta object");
    bool hasAtm = true;
    vol_ = QuantLib::ext::make_shared<BlackVolatilitySurfaceDelta>(
        asof, expiryDates, putDeltas, callDeltas, hasAtm, vols, dayCounter_, calendar_, eqIndex->equitySpot(),
        eqIndex->equityForecastCurve(), eqIndex->equityDividendCurve(), deltaType, atmType, atmDeltaType, 0 * Days,
        deltaType, atmType, atmDeltaType, im, flatExtrapolation);
 
    DLOG("EquityVolCurve: Setting BlackVolatilitySurfaceDelta extrapolation to " << to_string(vdsc.extrapolation()));
    vol_->enableExtrapolation(vdsc.extrapolation());
 
    DLOG("EquityVolCurve: finished building 2-D volatility delta strike surface");
}

Here is the call graph for this function:

buildVolatility() [6/6]

void buildVolatility	(	const QuantLib::Date &	asof,
		const EquityVolatilityCurveSpec &	spec,
		const CurveConfigurations &	curveConfigs,
		const ProxyVolatilityConfig &	epvc,
		const map< string, QuantLib::ext::shared_ptr< EquityCurve > > &	eqCurves,
		const map< string, QuantLib::ext::shared_ptr< EquityVolCurve > > &	eqVolCurves,
		const map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &	fxVolCurves,
		const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &	requiredCorrelationCurves,
		const Market *	fxIndices = nullptr
	)

Build a volatility surface as a proxy from another volatility surface.

Definition at line 1003 of file equityvolcurve.cpp.

                                                              {
 
    DLOG("EquityVolCurve: start building proxy vol surface");
    // get all the configurations and the curve needed for proxying
    auto config = *curveConfigs.equityVolCurveConfig(spec.curveConfigID());
    
    auto proxy = epvc.proxyVolatilityCurve();
    auto eqConfig = *curveConfigs.equityCurveConfig(spec.curveConfigID());
    auto proxyConfig = *curveConfigs.equityCurveConfig(proxy);
    auto proxyVolConfig = *curveConfigs.equityVolCurveConfig(proxy);
 
    // create dummy specs to look up the required curves
    EquityCurveSpec eqSpec(eqConfig.currency(), spec.curveConfigID());
    EquityCurveSpec proxySpec(proxyConfig.currency(), proxy);
    EquityVolatilityCurveSpec proxyVolSpec(proxyVolConfig.ccy(), proxy);
 
    // Get all necessary curves
    auto curve = eqCurves.find(eqSpec.name());
    QL_REQUIRE(curve != eqCurves.end(), "EquityVolCurve: Failed to find equity curve, when building equity vol curve " << spec.name());
    auto proxyCurve = eqCurves.find(proxySpec.name());
    QL_REQUIRE(proxyCurve != eqCurves.end(), "EquityVolCurve: Failed to find equity curve for proxy "
                                                 << proxySpec.name() << ", when building equity vol curve "
                                                 << spec.name());
    auto proxyVolCurve = eqVolCurves.find(proxyVolSpec.name());
    QL_REQUIRE(proxyVolCurve != eqVolCurves.end(), "EquityVolCurve: Failed to find equity vol curve for proxy "
                                                       << proxyVolSpec.name() << ", when building equity vol curve "
                                                       << spec.name());
 
    // check the currency against the proxy surface currrency
 
    QuantLib::ext::shared_ptr<BlackVolTermStructure> fxSurface;
    QuantLib::ext::shared_ptr<FxIndex> fxIndex;
    QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure> correlation;
    if (config.ccy() != proxyVolConfig.ccy() && fxIndices != nullptr) {
        QL_REQUIRE(!epvc.fxVolatilityCurve().empty(), "EquityVolCurve: FXVolatilityCurve must be provided for Equity vol config " << 
            spec.curveConfigID() << " as proxy currencies if different from equity currency.");
        QL_REQUIRE(!epvc.correlationCurve().empty(), "EquityVolCurve: CorrelationCurve must be provided for Equity vol config " <<
            spec.curveConfigID() << " as proxy currencies if different from equity currency.");
 
        // get the fx vol surface
        QL_REQUIRE(epvc.fxVolatilityCurve().size() == 6, "EquityVolCurve: FXVolatilityCurve provided " << epvc.fxVolatilityCurve() <<
            " for Equity vol config " << spec.curveConfigID() << " must be of length 6, and of form CC1CCY2 e.g EURUSD");
        string proxyVolForCcy = epvc.fxVolatilityCurve().substr(0, 3);
        string proxyVolDomCcy = epvc.fxVolatilityCurve().substr(3, 3);
        FXVolatilityCurveSpec fxSpec(proxyVolForCcy, proxyVolDomCcy, epvc.fxVolatilityCurve());
        auto volIt = fxVolCurves.find(fxSpec.name());
        if (volIt == fxVolCurves.end())
            QL_FAIL("EquityVolCurve: cannot find required Fx volatility surface " << fxSpec.name() << " to build proxy vol surface for " << eqSpec.name());
        fxSurface = volIt->second->volTermStructure();
 
        // check if the fx vol surface needs to be inverted
        if (proxyVolForCcy != proxyVolConfig.ccy()) {
            Handle<BlackVolTermStructure> hFx(fxSurface);
            fxSurface = QuantLib::ext::make_shared<QuantExt::BlackInvertedVolTermStructure>(hFx);
            fxSurface->enableExtrapolation();
        }
 
        fxIndex = fxIndices->fxIndex(proxyVolConfig.ccy() + config.ccy()).currentLink();
 
        CorrelationCurveSpec corrSpec(epvc.correlationCurve());
        auto corrIt = requiredCorrelationCurves.find(corrSpec.name());
        if (corrIt == requiredCorrelationCurves.end())
            QL_FAIL("EquityVolCurve: cannot find required correlation curve " << epvc.correlationCurve() << " to build proxy vol surface for " << eqSpec.name());
        correlation = corrIt->second->corrTermStructure();
    }
 
    vol_ = QuantLib::ext::make_shared<BlackVolatilitySurfaceProxy>(proxyVolCurve->second->volTermStructure(), curve->second->equityIndex(),
        proxyCurve->second->equityIndex(), fxSurface, fxIndex, correlation);
}

Here is the call graph for this function:

buildCalibrationInfo()

void buildCalibrationInfo	(	const QuantLib::Date &	asof,
		const CurveConfigurations &	curveConfigs,
		const EquityVolatilityCurveConfig &	config,
		const Handle< QuantExt::EquityIndex2 > &	eqIndex
	)

Build the calibration info.

Definition at line 1079 of file equityvolcurve.cpp.

                                                                               {
 
    DLOG("EquityVolCurve: Building calibration info for eq vol surface");
 
    try {
 
        ReportConfig rc = effectiveReportConfig(curveConfigs.reportConfigEqVols(), config.reportConfig());
 
        bool reportOnDeltaGrid = *rc.reportOnDeltaGrid();
        bool reportOnMoneynessGrid = *rc.reportOnMoneynessGrid();
        std::vector<Real> moneyness = *rc.moneyness();
        std::vector<std::string> deltas = *rc.deltas();
        std::vector<Period> expiries = *rc.expiries();
 
        calibrationInfo_ = QuantLib::ext::make_shared<FxEqCommVolCalibrationInfo>();
 
        DeltaVolQuote::AtmType atmType = DeltaVolQuote::AtmType::AtmDeltaNeutral;
        DeltaVolQuote::DeltaType deltaType = DeltaVolQuote::DeltaType::Fwd;
 
        if (auto vdsc = QuantLib::ext::dynamic_pointer_cast<VolatilityDeltaSurfaceConfig>(volatilityConfig_)) {
            atmType = parseAtmType(vdsc->atmType());
            deltaType = parseDeltaType(vdsc->deltaType());
        }
 
        calibrationInfo_->dayCounter = config.dayCounter().empty() ? "na" : config.dayCounter();
        calibrationInfo_->calendar = config.calendar().empty() ? "na" : config.calendar();
        calibrationInfo_->atmType = ore::data::to_string(atmType);
        calibrationInfo_->deltaType = ore::data::to_string(deltaType);
        calibrationInfo_->longTermAtmType = ore::data::to_string(atmType);
        calibrationInfo_->longTermDeltaType = ore::data::to_string(deltaType);
        calibrationInfo_->switchTenor = "na";
        calibrationInfo_->riskReversalInFavorOf = "na";
        calibrationInfo_->butterflyStyle = "na";
 
        std::vector<Real> times, forwards, rfDisc, divDisc;
        for (auto const& p : expiries) {
            Date d = vol_->optionDateFromTenor(p);
            calibrationInfo_->expiryDates.push_back(d);
            times.push_back(vol_->dayCounter().empty() ? Actual365Fixed().yearFraction(asof, d)
                                                       : vol_->timeFromReference(d));
            forwards.push_back(eqIndex->forecastFixing(d));
            rfDisc.push_back(eqIndex->equityForecastCurve()->discount(d));
            divDisc.push_back(eqIndex->equityDividendCurve()->discount(d));
        }
 
        calibrationInfo_->times = times;
        calibrationInfo_->forwards = forwards;
 
        std::vector<std::vector<Real>> callPricesDelta(times.size(), std::vector<Real>(deltas.size(), 0.0));
        std::vector<std::vector<Real>> callPricesMoneyness(times.size(), std::vector<Real>(moneyness.size(), 0.0));
 
        calibrationInfo_->isArbitrageFree = true;
 
        if (reportOnDeltaGrid) {
            calibrationInfo_->deltas = deltas;
            calibrationInfo_->deltaCallPrices =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(deltas.size(), 0.0));
            calibrationInfo_->deltaPutPrices =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(deltas.size(), 0.0));
            calibrationInfo_->deltaGridStrikes =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(deltas.size(), 0.0));
            calibrationInfo_->deltaGridProb =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(deltas.size(), 0.0));
            calibrationInfo_->deltaGridImpliedVolatility =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(deltas.size(), 0.0));
            calibrationInfo_->deltaGridCallSpreadArbitrage =
                std::vector<std::vector<bool>>(times.size(), std::vector<bool>(deltas.size(), true));
            calibrationInfo_->deltaGridButterflyArbitrage =
                std::vector<std::vector<bool>>(times.size(), std::vector<bool>(deltas.size(), true));
            TLOG("EquityVolCurve: Delta surface arbitrage analysis result (no calendar spread arbitrage included):");
            Real maxTime = QL_MAX_REAL;
            if (maxExpiry_ != Date()) {
                if (vol_->dayCounter().empty())
                    maxTime = Actual365Fixed().yearFraction(asof, maxExpiry_);
                else
                    maxTime = vol_->timeFromReference(maxExpiry_);
            }
            DeltaVolQuote::AtmType at;
            DeltaVolQuote::DeltaType dt;
            for (Size i = 0; i < times.size(); ++i) {
                Real t = times[i];
                at = atmType;
                dt = deltaType;
                // for times after the last quoted expiry we use artificial conventions to avoid problems with strike
                // from delta conversions: we use fwd delta always and ATM DNS
                if (t > maxTime) {
                    at = DeltaVolQuote::AtmDeltaNeutral;
                    dt = DeltaVolQuote::Fwd;
                }
                bool validSlice = true;
                for (Size j = 0; j < deltas.size(); ++j) {
                    DeltaString d(deltas[j]);
                    try {
                        Real strike;
                        if (d.isAtm()) {
                            strike = QuantExt::getAtmStrike(dt, at, eqIndex->equitySpot()->value(), rfDisc[i],
                                                            divDisc[i], vol_, t);
                        } else if (d.isCall()) {
                            strike = QuantExt::getStrikeFromDelta(Option::Call, d.delta(), dt,
                                                                  eqIndex->equitySpot()->value(), rfDisc[i], divDisc[i],
                                                                  vol_, t);
                        } else {
                            strike =
                                QuantExt::getStrikeFromDelta(Option::Put, d.delta(), dt, eqIndex->equitySpot()->value(),
                                                             rfDisc[i], divDisc[i], vol_, t);
                        }
                        Real stddev = std::sqrt(vol_->blackVariance(t, strike));
                        callPricesDelta[i][j] = blackFormula(Option::Call, strike, forwards[i], stddev);
 
                        if (d.isPut()) {
                            calibrationInfo_->deltaPutPrices[i][j] = blackFormula(Option::Put, strike, forwards[i], stddev, rfDisc[i]);
                        } else {
                            calibrationInfo_->deltaCallPrices[i][j] = blackFormula(Option::Call, strike, forwards[i], stddev, rfDisc[i]);
                        }
 
                        calibrationInfo_->deltaGridStrikes[i][j] = strike;
                        calibrationInfo_->deltaGridImpliedVolatility[i][j] = stddev / std::sqrt(t);
                    } catch (const std::exception& e) {
                        validSlice = false;
                        TLOG("EquityVolCurve: error for time " << t << " delta " << deltas[j] << ": " << e.what());
                    }
                }
                if (validSlice) {
                    try {
                        QuantExt::CarrMadanMarginalProbability cm(calibrationInfo_->deltaGridStrikes[i], forwards[i],
                                                                  callPricesDelta[i]);
                        calibrationInfo_->deltaGridCallSpreadArbitrage[i] = cm.callSpreadArbitrage();
                        calibrationInfo_->deltaGridButterflyArbitrage[i] = cm.butterflyArbitrage();
                        if (!cm.arbitrageFree())
                            calibrationInfo_->isArbitrageFree = false;
                        calibrationInfo_->deltaGridProb[i] = cm.density();
                        TLOGGERSTREAM(arbitrageAsString(cm));
                    } catch (const std::exception& e) {
                        TLOG("error for time " << t << ": " << e.what());
                        calibrationInfo_->isArbitrageFree = false;
                        TLOGGERSTREAM("..(invalid slice)..");
                    }
                } else {
                    calibrationInfo_->isArbitrageFree = false;
                    TLOGGERSTREAM("..(invalid slice)..");
                }
            }
            TLOG("EquityVolCurve: Delta surface arbitrage analysis completed.");
        }
 
        if (reportOnMoneynessGrid) {
            calibrationInfo_->moneyness = moneyness;
            calibrationInfo_->moneynessCallPrices =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(moneyness.size(), 0.0));
            calibrationInfo_->moneynessPutPrices =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(moneyness.size(), 0.0));
            calibrationInfo_->moneynessGridStrikes =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(moneyness.size(), 0.0));
            calibrationInfo_->moneynessGridProb =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(moneyness.size(), 0.0));
            calibrationInfo_->moneynessGridImpliedVolatility =
                std::vector<std::vector<Real>>(times.size(), std::vector<Real>(moneyness.size(), 0.0));
            calibrationInfo_->moneynessGridCallSpreadArbitrage =
                std::vector<std::vector<bool>>(times.size(), std::vector<bool>(moneyness.size(), true));
            calibrationInfo_->moneynessGridButterflyArbitrage =
                std::vector<std::vector<bool>>(times.size(), std::vector<bool>(moneyness.size(), true));
            calibrationInfo_->moneynessGridCalendarArbitrage =
                std::vector<std::vector<bool>>(times.size(), std::vector<bool>(moneyness.size(), true));
            for (Size i = 0; i < times.size(); ++i) {
                Real t = times[i];
                for (Size j = 0; j < moneyness.size(); ++j) {
                    try {
                        Real strike = moneyness[j] * forwards[i];
                        calibrationInfo_->moneynessGridStrikes[i][j] = strike;
                        Real stddev = std::sqrt(vol_->blackVariance(t, strike));
                        callPricesMoneyness[i][j] = blackFormula(Option::Call, strike, forwards[i], stddev);
                        calibrationInfo_->moneynessGridImpliedVolatility[i][j] = stddev / std::sqrt(t);
                        if (moneyness[j] >= 1) {
                            calibrationInfo_->moneynessCallPrices[i][j] = blackFormula(Option::Call, strike, forwards[i], stddev, rfDisc[i]);
                        } else {
                            calibrationInfo_->moneynessPutPrices[i][j] = blackFormula(Option::Put, strike, forwards[i], stddev, rfDisc[i]);
                        };
                    } catch (const std::exception& e) {
                        TLOG("EquityVolCurve: error for time " << t << " moneyness " << moneyness[j] << ": " << e.what());
                    }
                }
            }
            if (!times.empty() && !moneyness.empty()) {
                try {
                    QuantExt::CarrMadanSurface cm(times, moneyness, eqIndex->equitySpot()->value(), forwards,
                                                  callPricesMoneyness);
                    for (Size i = 0; i < times.size(); ++i) {
                        calibrationInfo_->moneynessGridProb[i] = cm.timeSlices()[i].density();
                    }
                    calibrationInfo_->moneynessGridCallSpreadArbitrage = cm.callSpreadArbitrage();
                    calibrationInfo_->moneynessGridButterflyArbitrage = cm.butterflyArbitrage();
                    calibrationInfo_->moneynessGridCalendarArbitrage = cm.calendarArbitrage();
                    if (!cm.arbitrageFree())
                        calibrationInfo_->isArbitrageFree = false;
                    TLOG("EquityVolCurve: Moneyness surface Arbitrage analysis result:");
                    TLOGGERSTREAM(arbitrageAsString(cm));
                } catch (const std::exception& e) {
                    TLOG("EquityVolCurve: error: " << e.what());
                    calibrationInfo_->isArbitrageFree = false;
                }
                TLOG("EquityVolCurve: Moneyness surface Arbitrage analysis completed:");
            }
        }
 
        DLOG("EquityVolCurve: Building calibration info for eq vol surface completed.");
 
    } catch (std::exception& e) {
        QL_FAIL("EquityVolCurve: calibration info building failed: " << e.what());
    } catch (...) {
        QL_FAIL("EquityVolCurve:  calibration info building failed: unknown error");
    }
}

Here is the call graph for this function:

volTermStructure()

const QuantLib::ext::shared_ptr< BlackVolTermStructure > & volTermStructure

(

)

const

Definition at line 100 of file equityvolcurve.hpp.

{ return vol_; }

calibrationInfo()

const QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo > & calibrationInfo

(

)

const

Definition at line 101 of file equityvolcurve.hpp.

{ return calibrationInfo_; }

Member Data Documentation

spec_

EquityVolatilityCurveSpec spec_

private

Definition at line 106 of file equityvolcurve.hpp.

vol_

QuantLib::ext::shared_ptr<BlackVolTermStructure> vol_

private

Definition at line 107 of file equityvolcurve.hpp.

calendar_

QuantLib::Calendar calendar_

private

Definition at line 108 of file equityvolcurve.hpp.

currency_

QuantLib::Currency currency_

private

Definition at line 109 of file equityvolcurve.hpp.

dayCounter_

QuantLib::DayCounter dayCounter_

private

Definition at line 110 of file equityvolcurve.hpp.

maxExpiry_

QuantLib::Date maxExpiry_

private

Definition at line 111 of file equityvolcurve.hpp.

volatilityConfig_

QuantLib::ext::shared_ptr<VolatilityConfig> volatilityConfig_

private

Definition at line 112 of file equityvolcurve.hpp.

calibrationInfo_

QuantLib::ext::shared_ptr<FxEqCommVolCalibrationInfo> calibrationInfo_

private

Definition at line 113 of file equityvolcurve.hpp.