FXVolCurve Class Reference

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

#include <ored/marketdata/fxvolcurve.hpp>

Collaboration diagram for FXVolCurve:

Public Member Functions
Constructors
	FXVolCurve ()
	Default constructor. More...
	FXVolCurve (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, const CurveConfigurations &curveConfigs, const ore::data::FXTriangulation &fxSpots, const std::map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, const std::map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &fxVols, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &correlationCurves, const bool buildCalibrationInfo)
	Detailed constructor. More...

Inspectors
FXVolatilityCurveSpec	spec_
QuantLib::ext::shared_ptr< BlackVolTermStructure >	vol_
Handle< Quote >	fxSpot_
Handle< YieldTermStructure >	domYts_
Handle< YieldTermStructure >	forYts_
string	sourceCcy_
string	targetCcy_
std::vector< string >	expiriesNoDuplicates_
std::vector< Period >	expiries_
boost::optional< Wildcard >	expiriesWildcard_
Size	spotDays_
Calendar	spotCalendar_
QuantLib::Period	switchTenor_
QuantLib::DeltaVolQuote::AtmType	atmType_
QuantLib::DeltaVolQuote::DeltaType	deltaType_
QuantLib::DeltaVolQuote::AtmType	longTermAtmType_
QuantLib::DeltaVolQuote::DeltaType	longTermDeltaType_
QuantLib::Option::Type	riskReversalInFavorOf_
bool	butterflyIsBrokerStyle_
QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo >	calibrationInfo_
const FXVolatilityCurveSpec &	spec () const
const QuantLib::ext::shared_ptr< BlackVolTermStructure > &	volTermStructure ()
QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo >	calibrationInfo () const
void	init (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, const CurveConfigurations &curveConfigs, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, const std::map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &fxVols, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &correlationCurves, const bool buildCalibrationInfo)
void	buildATMTriangulated (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig > config, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, const std::map< std::string, QuantLib::ext::shared_ptr< FXVolCurve > > &fxVols, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &correlationCurves)
void	buildSmileDeltaCurve (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig > config, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)
void	buildSmileBfRrCurve (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig > config, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)
void	buildVannaVolgaOrATMCurve (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig > config, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)
void	buildSmileAbsoluteCurve (Date asof, FXVolatilityCurveSpec spec, const Loader &loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig > config, const FXTriangulation &fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)

Detailed Description

Wrapper class for building FX volatility structures.

Definition at line 46 of file fxvolcurve.hpp.

Constructor & Destructor Documentation

FXVolCurve() [1/2]

FXVolCurve

(

)

Default constructor.

Definition at line 51 of file fxvolcurve.hpp.

{}

FXVolCurve() [2/2]

FXVolCurve	(	Date	asof,
		FXVolatilityCurveSpec	spec,
		const Loader &	loader,
		const CurveConfigurations &	curveConfigs,
		const ore::data::FXTriangulation &	fxSpots,
		const std::map< string, QuantLib::ext::shared_ptr< YieldCurve > > &	yieldCurves,
		const std::map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &	fxVols,
		const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &	correlationCurves,
		const bool	buildCalibrationInfo
	)

Detailed constructor.

Definition at line 63 of file fxvolcurve.cpp.

                                                        {
    init(asof, spec, loader, curveConfigs, fxSpots, yieldCurves, fxVols, correlationCurves, buildCalibrationInfo);
}

Here is the call graph for this function:

Member Function Documentation

spec()

const FXVolatilityCurveSpec & spec

(

)

const

Definition at line 63 of file fxvolcurve.hpp.

{ return spec_; }

Here is the caller graph for this function:

volTermStructure()

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

(

)

Definition at line 64 of file fxvolcurve.hpp.

{ return vol_; }

calibrationInfo()

QuantLib::ext::shared_ptr< FxEqCommVolCalibrationInfo > calibrationInfo

(

)

const

Definition at line 65 of file fxvolcurve.hpp.

{ return calibrationInfo_; }

init()

void init ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, const CurveConfigurations &  curveConfigs, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves, const std::map< string, QuantLib::ext::shared_ptr< FXVolCurve > > &  fxVols, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &  correlationCurves, const bool  buildCalibrationInfo  )

private

Definition at line 800 of file fxvolcurve.cpp.

                                                       {
    try {
 
        const QuantLib::ext::shared_ptr<FXVolatilityCurveConfig>& config = curveConfigs.fxVolCurveConfig(spec.curveConfigID());
        QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
 
        QL_REQUIRE(config->dimension() == FXVolatilityCurveConfig::Dimension::ATM ||
                       config->dimension() == FXVolatilityCurveConfig::Dimension::ATMTriangulated ||
                       config->dimension() == FXVolatilityCurveConfig::Dimension::SmileVannaVolga ||
                       config->dimension() == FXVolatilityCurveConfig::Dimension::SmileDelta ||
                       config->dimension() == FXVolatilityCurveConfig::Dimension::SmileBFRR ||
                       config->dimension() == FXVolatilityCurveConfig::Dimension::SmileAbsolute,
                   "Unknown FX curve building dimension");
 
        expiriesWildcard_ = getUniqueWildcard(config->expiries());
 
        // remove expiries that would lead to duplicate expiry dates (keep the later expiry in this case)
 
        if (expiriesWildcard_) {
            DLOG("expiry wildcard is used: " << expiriesWildcard_->pattern());
        } else {
            std::vector<std::tuple<std::string, Period, Date>> tmp;
            for (auto const& e : config->expiries()) {
                auto p = parsePeriod(e);
                tmp.push_back(std::make_tuple(e, p, config->calendar().advance(asof, p)));
            }
            std::sort(tmp.begin(), tmp.end(),
                      [](const std::tuple<std::string, Period, Date>& a,
                         const std::tuple<std::string, Period, Date>& b) -> bool {
                          if (std::get<2>(a) == std::get<2>(b)) {
                              try {
                                  // equal dates => compare periods (might throw!)
                                  return std::get<1>(a) < std::get<1>(b);
                              } catch (...) {
                                  // period comparison not possible => compare the strings
                                  return std::get<0>(a) < std::get<0>(b);
                              }
                          }
                          // different dates => compare them
                          return std::get<2>(a) < std::get<2>(b);
                      });
            Date lastDate = Date::maxDate();
            for (Size i = tmp.size(); i > 0; --i) {
                if (std::get<2>(tmp[i - 1]) == lastDate)
                    continue;
                expiriesNoDuplicates_.insert(expiriesNoDuplicates_.begin(), std::get<0>(tmp[i - 1]));
                lastDate = std::get<2>(tmp[i - 1]);
            }
 
            DLOG("expiries in configuration:")
            for (auto const& e : config->expiries()) {
                DLOG(e);
            }
 
            DLOG("expiries after removing duplicate expiry dates and sorting:");
            for (auto const& e : expiriesNoDuplicates_) {
                DLOG(e);
            }
        }
 
        QL_REQUIRE(config->dimension() == FXVolatilityCurveConfig::Dimension::ATMTriangulated || expiriesWildcard_ ||
                       !expiriesNoDuplicates_.empty(),
                   "no expiries after removing duplicate expiry dates");
 
        std::vector<std::string> tokens;
        boost::split(tokens, config->fxSpotID(), boost::is_any_of("/"));
        QL_REQUIRE(tokens.size() == 3, "Expected 3 tokens in fx spot id '" << config->fxSpotID() << "'");
        sourceCcy_ = tokens[1];
        targetCcy_ = tokens[2];
 
        atmType_ = DeltaVolQuote::AtmType::AtmDeltaNeutral;
        deltaType_ = DeltaVolQuote::DeltaType::Spot;
        switchTenor_ = 2 * Years;
        longTermAtmType_ = DeltaVolQuote::AtmType::AtmDeltaNeutral;
        longTermDeltaType_ = DeltaVolQuote::DeltaType::Fwd;
        riskReversalInFavorOf_ = Option::Call;
        butterflyIsBrokerStyle_ = true;
        spotDays_ = 2;
        string calTmp = sourceCcy_ + "," + targetCcy_;
        spotCalendar_ = parseCalendar(calTmp);
 
        if (config->conventionsID() == "") {
            WLOG("no fx option conventions given in fxvol curve config for " << spec.curveConfigID()
                                                                             << ", assuming defaults");
        } else {
            auto fxOptConv = QuantLib::ext::dynamic_pointer_cast<FxOptionConvention>(conventions->get(config->conventionsID()));
            QL_REQUIRE(fxOptConv,
                       "unable to cast convention '" << config->conventionsID() << "' into FxOptionConvention");
            QuantLib::ext::shared_ptr<FXConvention> fxConv;
            if (!fxOptConv->fxConventionID().empty()) {
                fxConv = QuantLib::ext::dynamic_pointer_cast<FXConvention>(conventions->get(fxOptConv->fxConventionID()));
                QL_REQUIRE(fxConv, "unable to cast convention '" << fxOptConv->fxConventionID()
                                                                 << "', from FxOptionConvention '"
                                                                 << config->conventionsID() << "' into FxConvention");
            }
            atmType_ = fxOptConv->atmType();
            deltaType_ = fxOptConv->deltaType();
            longTermAtmType_ = fxOptConv->longTermAtmType();
            longTermDeltaType_ = fxOptConv->longTermDeltaType();
            switchTenor_ = fxOptConv->switchTenor();
            riskReversalInFavorOf_ = fxOptConv->riskReversalInFavorOf();
            butterflyIsBrokerStyle_ = fxOptConv->butterflyIsBrokerStyle();
            if (fxConv) {
                spotDays_ = fxConv->spotDays();
                spotCalendar_ = fxConv->advanceCalendar();
            }
        }
 
        auto spotSpec = QuantLib::ext::dynamic_pointer_cast<FXSpotSpec>(parseCurveSpec(config->fxSpotID()));
        QL_REQUIRE(spotSpec != nullptr,
                   "could not parse '" << config->fxSpotID() << "' to FXSpotSpec, expected FX/CCY1/CCY2");
        fxSpot_ = fxSpots.getQuote(spotSpec->unitCcy() + spotSpec->ccy());
        if (!config->fxDomesticYieldCurveID().empty())
            domYts_ = getHandle<YieldTermStructure>(config->fxDomesticYieldCurveID(), yieldCurves);
        if (!config->fxForeignYieldCurveID().empty())
            forYts_ = getHandle<YieldTermStructure>(config->fxForeignYieldCurveID(), yieldCurves);
 
        if (config->dimension() == FXVolatilityCurveConfig::Dimension::SmileDelta) {
            buildSmileDeltaCurve(asof, spec, loader, config, fxSpots, yieldCurves);
        } else if (config->dimension() == FXVolatilityCurveConfig::Dimension::SmileBFRR) {
            buildSmileBfRrCurve(asof, spec, loader, config, fxSpots, yieldCurves);
        } else if (config->dimension() == FXVolatilityCurveConfig::Dimension::ATMTriangulated) {
            buildATMTriangulated(asof, spec, loader, config, fxSpots, yieldCurves, fxVols, correlationCurves);
        } else if (config->dimension() == FXVolatilityCurveConfig::Dimension::SmileAbsolute) {
            buildSmileAbsoluteCurve(asof, spec, loader, config, fxSpots, yieldCurves);
        } else {
            buildVannaVolgaOrATMCurve(asof, spec, loader, config, fxSpots, yieldCurves);
        }
 
        // build calibration info
 
        if (buildCalibrationInfo) {
 
            DLOG("Building calibration info for fx vol surface");
 
            if (domYts_.empty() || forYts_.empty()) {
                WLOG("no domestic / foreign yield curves given in fx vol curve config for "
                     << spec.curveConfigID() << ", skip building calibration info");
                return;
            }
 
            ReportConfig rc = effectiveReportConfig(curveConfigs.reportConfigFxVols(), 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>();
 
            calibrationInfo_->dayCounter = config->dayCounter().empty() ? "na" : config->dayCounter().name();
            calibrationInfo_->calendar = config->calendar().empty() ? "na" : config->calendar().name();
            calibrationInfo_->atmType = ore::data::to_string(atmType_);
            calibrationInfo_->deltaType = ore::data::to_string(deltaType_);
            calibrationInfo_->longTermAtmType = ore::data::to_string(longTermAtmType_);
            calibrationInfo_->longTermDeltaType = ore::data::to_string(longTermDeltaType_);
            calibrationInfo_->switchTenor = ore::data::to_string(switchTenor_);
            calibrationInfo_->riskReversalInFavorOf = riskReversalInFavorOf_ == Option::Call ? "Call" : "Put";
            calibrationInfo_->butterflyStyle = butterflyIsBrokerStyle_ ? "Broker" : "Smile";
 
            std::vector<Real> times, forwards, domDisc, forDisc;
            Date settl = spotCalendar_.advance(asof, spotDays_ * Days);
            for (auto const& p : expiries) {
                Date d = vol_->optionDateFromTenor(p);
                Date settlFwd = spotCalendar_.advance(d, spotDays_ * Days);
                calibrationInfo_->expiryDates.push_back(d);
                times.push_back(vol_->dayCounter().empty() ? Actual365Fixed().yearFraction(asof, d)
                                                           : vol_->timeFromReference(d));
                domDisc.push_back(domYts_->discount(settlFwd) / domYts_->discount(settl));
                forDisc.push_back(forYts_->discount(settlFwd) / forYts_->discount(settl));
                forwards.push_back(fxSpot_->value() / domDisc.back() * forDisc.back());
            }
 
            calibrationInfo_->times = times;
            calibrationInfo_->forwards = forwards;
 
            Date switchExpiry =
                vol_->calendar().empty() ? asof + switchTenor_ : vol_->optionDateFromTenor(switchTenor_);
            Real switchTime = vol_->dayCounter().empty() ? Actual365Fixed().yearFraction(asof, switchExpiry)
                                                         : vol_->timeFromReference(switchExpiry);
            if (switchTenor_ == 0 * Days)
                switchTime = QL_MAX_REAL;
 
            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));
                DeltaVolQuote::DeltaType dt;
                DeltaVolQuote::AtmType at;
                TLOG("Delta surface arbitrage analysis result (no calendar spread arbitrage included):");
                Real maxTime = QL_MAX_REAL;
                if (!expiries_.empty())
                    maxTime = vol_->timeFromReference(vol_->optionDateFromTenor(expiries_.back()));
                for (Size i = 0; i < times.size(); ++i) {
                    Real t = times[i];
                    if (t <= switchTime || close_enough(t, switchTime)) {
                        at = atmType_;
                        dt = deltaType_;
                    } else {
                        at = longTermAtmType_;
                        dt = longTermDeltaType_;
                    }
                    // for times after the last quoted expiry we use artificial conventions to avoid problems with
                    // strike from delta conversions: we keep the pa feature, but use fwd delta always and ATM DNS
                    if (t > maxTime) {
                        at = DeltaVolQuote::AtmDeltaNeutral;
                        dt = (deltaType_ == DeltaVolQuote::Spot || deltaType_ == DeltaVolQuote::Fwd)
                                 ? DeltaVolQuote::Fwd
                                 : DeltaVolQuote::PaFwd;
                    }
                    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, fxSpot_->value(), domDisc[i], forDisc[i], vol_, t);
                            } else if (d.isCall()) {
                                strike = QuantExt::getStrikeFromDelta(Option::Call, d.delta(), dt, fxSpot_->value(),
                                                                      domDisc[i], forDisc[i], vol_, t);
                            } else {
                                strike = QuantExt::getStrikeFromDelta(Option::Put, d.delta(), dt, fxSpot_->value(),
                                                                      domDisc[i], forDisc[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, domDisc[i]);
                            } else {
                                calibrationInfo_->deltaCallPrices[i][j] = blackFormula(Option::Call, strike, forwards[i], stddev, domDisc[i]);
                            }
                            
                            calibrationInfo_->deltaGridStrikes[i][j] = strike;
                            calibrationInfo_->deltaGridImpliedVolatility[i][j] = stddev / std::sqrt(t);
                        } catch (const std::exception& e) {
                            validSlice = false;
                            TLOG("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("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, domDisc[i]);
                            } else {
                                calibrationInfo_->moneynessPutPrices[i][j] = blackFormula(Option::Put, strike, forwards[i], stddev, domDisc[i]);
                            };
                        } catch (const std::exception& e) {
                            TLOG("error for time " << t << " moneyness " << moneyness[j] << ": " << e.what());
                        }
                    }
                }
                if (!times.empty() && !moneyness.empty()) {
                    try {
                        QuantExt::CarrMadanSurface cm(times, moneyness, fxSpot_->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("Moneyness surface Arbitrage analysis result:");
                        TLOGGERSTREAM(arbitrageAsString(cm));
                    } catch (const std::exception& e) {
                        TLOG("error: " << e.what());
                        calibrationInfo_->isArbitrageFree = false;
                    }
                    TLOG("Moneyness surface Arbitrage analysis completed:");
                }
            }
 
            // the bfrr surface provides info on smiles with error, which we report here
 
            if (reportOnDeltaGrid || reportOnMoneynessGrid) {
                if (auto bfrr = QuantLib::ext::dynamic_pointer_cast<QuantExt::BlackVolatilitySurfaceBFRR>(vol_)) {
                    if (bfrr->deltas().size() != bfrr->currentDeltas().size()) {
                        calibrationInfo_->messages.push_back(
                            "Warning: Used only " + std::to_string(bfrr->currentDeltas().size()) + " deltas of the " +
                            std::to_string(bfrr->deltas().size()) +
                            " deltas that were initially provided, because all smiles were invalid.");
                    }
                    for (Size i = 0; i < bfrr->dates().size(); ++i) {
                        if (bfrr->smileHasError()[i]) {
                            calibrationInfo_->messages.push_back("Ignore invalid smile at expiry " +
                                                                 ore::data::to_string(bfrr->dates()[i]) + ": " +
                                                                 bfrr->smileErrorMessage()[i]);
                        }
                    }
                }
            }
 
            DLOG("Building calibration info for fx vol surface completed.");
        }
 
    } catch (std::exception& e) {
        QL_FAIL("fx vol curve building failed: " << e.what());
    } catch (...) {
        QL_FAIL("fx vol curve building failed: unknown error");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildATMTriangulated()

void buildATMTriangulated ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig >  config, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves, const std::map< std::string, QuantLib::ext::shared_ptr< FXVolCurve > > &  fxVols, const map< string, QuantLib::ext::shared_ptr< CorrelationCurve > > &  correlationCurves  )

private

Definition at line 720 of file fxvolcurve.cpp.

                                                                                                                     {
 
    DLOG("Triangulating FxVol curve " << config->curveID() << " from baseVols " << config->baseVolatility1() << ":"
                                      << config->baseVolatility2());
 
    std::string baseCcy;
    QL_REQUIRE(config->baseVolatility1().size() == 6, "invalid ccy pair length for baseVolatility1");
    auto forBase1 = config->baseVolatility1().substr(0, 3);
    auto domBase1 = config->baseVolatility1().substr(3);
    std::string spec1 = "FXVolatility/" + forBase1 + "/" + domBase1 + "/" + config->baseVolatility1();
 
    bool base1Inverted = false;
    if (forBase1 != sourceCcy_ && forBase1 != targetCcy_) {
        // we invert the pair
        base1Inverted = true;
        std::string tmp = forBase1;
        forBase1 = targetCcy_;
        domBase1 = tmp;
 
        QL_REQUIRE(forBase1 == sourceCcy_ || forBase1 == targetCcy_,
                   "FxVol: mismatch in the baseVolatility1 " << config->baseVolatility1() << " and Target Pair "
                                                             << sourceCcy_ << targetCcy_);
    }
    baseCcy = domBase1;
 
    QL_REQUIRE(config->baseVolatility2().size() == 6, "invalid ccy pair length for baseVolatility2");
    auto forBase2 = config->baseVolatility2().substr(0, 3);
    auto domBase2 = config->baseVolatility2().substr(3);
    std::string spec2 = "FXVolatility/" + forBase2 + "/" + domBase2 + "/" + config->baseVolatility2();
    bool base2Inverted = false;
 
    QL_REQUIRE(forBase2 == baseCcy || domBase2 == baseCcy,
               "baseVolatility2 must share a ccy code with the baseVolatility1");
 
    if (forBase2 != sourceCcy_ && forBase2 != targetCcy_) {
        // we invert the pair
        std::string tmp = forBase2;
        forBase2 = targetCcy_;
        domBase2 = tmp;
        base2Inverted = true;
    }
 
    auto tmp = fxVols.find(spec1);
    QL_REQUIRE(tmp != fxVols.end(), "fx vol not found for " << config->baseVolatility1());
    Handle<BlackVolTermStructure> forBaseVol;
    if (base1Inverted) {
        auto h = Handle<BlackVolTermStructure>(tmp->second->volTermStructure());
        if (!h.empty())
            forBaseVol = Handle<BlackVolTermStructure>(QuantLib::ext::make_shared<QuantExt::BlackInvertedVolTermStructure>(h));
    } else {
        forBaseVol = Handle<BlackVolTermStructure>(tmp->second->volTermStructure());
    }
    forBaseVol->enableExtrapolation();
 
    tmp = fxVols.find(spec2);
    QL_REQUIRE(tmp != fxVols.end(), "fx vol not found for " << config->baseVolatility2());
    Handle<BlackVolTermStructure> domBaseVol;
    if (base2Inverted) {
        auto h = Handle<BlackVolTermStructure>(tmp->second->volTermStructure());
        if (!h.empty())
            domBaseVol = Handle<BlackVolTermStructure>(QuantLib::ext::make_shared<QuantExt::BlackInvertedVolTermStructure>(h));
 
    } else {
        domBaseVol = Handle<BlackVolTermStructure>(tmp->second->volTermStructure());
    }
    domBaseVol->enableExtrapolation();
 
    string forIndex = "FX-" + config->fxIndexTag() + "-" + sourceCcy_ + "-" + baseCcy;
    string domIndex = "FX-" + config->fxIndexTag() + "-" + targetCcy_ + "-" + baseCcy;
 
    Handle<QuantExt::CorrelationTermStructure> rho = getCorrelationCurve(forIndex, domIndex, correlationCurves);
 
    vol_ = QuantLib::ext::make_shared<QuantExt::BlackTriangulationATMVolTermStructure>(forBaseVol, domBaseVol, rho);
    vol_->enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildSmileDeltaCurve()

void buildSmileDeltaCurve ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig >  config, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Definition at line 72 of file fxvolcurve.cpp.

                                                                                                         {
    vector<Period> unsortedExp;
 
    vector<std::pair<Real, string>> putDeltas, callDeltas;
    bool hasATM = false;
 
    for (auto const& delta : config->deltas()) {
        DeltaString d(delta);
        if (d.isAtm())
            hasATM = true;
        else if (d.isPut())
            putDeltas.push_back(std::make_pair(d.delta(), delta));
        else if (d.isCall())
            callDeltas.push_back(std::make_pair(d.delta(), delta));
    }
 
    Calendar cal = config->calendar();
 
    // sort puts 10P, 15P, 20P, ... and calls 45C, 40C, 35C, ... (notice put deltas have a negative sign)
    auto comp = [](const std::pair<Real, string>& x, const std::pair<Real, string>& y) { return x.first > y.first; };
    std::sort(putDeltas.begin(), putDeltas.end(), comp);
    std::sort(callDeltas.begin(), callDeltas.end(), comp);
 
    vector<Date> dates;
    Matrix blackVolMatrix;
 
    string base = "FX_OPTION/RATE_LNVOL/" + sourceCcy_ + "/" + targetCcy_ + "/";
 
    // build quote names
    std::vector<std::string> deltaNames;
    for (auto const& d : putDeltas) {
        deltaNames.push_back(d.second);
    }
    if (hasATM) {
        deltaNames.push_back("ATM");
    }
    for (auto const& d : callDeltas) {
        deltaNames.push_back(d.second);
    }
 
    if (expiriesWildcard_) {
 
        // we save relevant delta quotes to avoid looping twice
        std::vector<QuantLib::ext::shared_ptr<MarketDatum>> data;
        std::vector<std::string> expiriesStr;
        // get list of possible expiries
        std::ostringstream ss;
        ss << MarketDatum::InstrumentType::FX_OPTION << "/RATE_LNVOL/" << spec.unitCcy()<< "/"
            << spec.ccy()<< "/*";
        Wildcard w(ss.str());
        for (const auto& md : loader.get(w, asof)) {
            QL_REQUIRE(md->asofDate() == asof, "MarketDatum asofDate '" << md->asofDate() << "' <> asof '" << asof << "'");
            QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
            QL_REQUIRE(q, "Internal error: could not downcast MarketDatum '" << md->name() << "' to FXOptionQuote");
            QL_REQUIRE(q->unitCcy() == spec.unitCcy(),
                "FXOptionQuote unit ccy '" << q->unitCcy() << "' <> FXVolatilityCurveSpec unit ccy '" << spec.unitCcy() << "'");
            QL_REQUIRE(q->ccy() == spec.ccy(),
                "FXOptionQuote ccy '" << q->ccy() << "' <> FXVolatilityCurveSpec ccy '" << spec.ccy() << "'");
            Strike s = parseStrike(q->strike());
            if (s.type == Strike::Type::DeltaCall || s.type == Strike::Type::DeltaPut || s.type == Strike::Type::ATM) {
                vector<string> tokens;
                boost::split(tokens, md->name(), boost::is_any_of("/"));
                QL_REQUIRE(tokens.size() == 6, "6 tokens expected in " << md->name());
                if (expiriesWildcard_->matches(tokens[4])) {
                    data.push_back(md);
                    auto it = std::find(expiries_.begin(), expiries_.end(), q->expiry());
                    if (it == expiries_.end()) {
                        expiries_.push_back(q->expiry());
                        expiriesStr.push_back(tokens[4]);
                    }
                }
            }
        }
        unsortedExp = expiries_;
        std::sort(expiries_.begin(), expiries_.end());
 
        // we try to find all necessary quotes for each expiry
        vector<Size> validExpiryIdx;
        Matrix tmpMatrix(expiries_.size(), config->deltas().size());
        for (Size i = 0; i < expiries_.size(); i++) {
            Size idx = std::find(unsortedExp.begin(), unsortedExp.end(), expiries_[i]) - unsortedExp.begin();
            string e = expiriesStr[idx];
            for (Size j = 0; j < deltaNames.size(); ++j) {
                string qs = base + e + "/" + deltaNames[j];
                QuantLib::ext::shared_ptr<MarketDatum> md;
                for (auto& m : data) {
                    if (m->name() == qs) {
                        md = m;
                        break;
                    }
                }
                QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
                if (!q) {
                    DLOG("missing " << qs << ", expiry " << e << " will be excluded");
                    break;
                }
                tmpMatrix[i][j] = q->quote()->value();
                // if we have found all the quotes then this is a valid expiry
                if (j == deltaNames.size() - 1) {
                    dates.push_back(cal.advance(asof, expiries_[i]));
                    validExpiryIdx.push_back(i);
                }
            }
        }
 
        QL_REQUIRE(validExpiryIdx.size() > 0, "no valid FxVol expiries found");
        DLOG("found " << validExpiryIdx.size() << " valid expiries:");
        for (auto& e : validExpiryIdx)
            DLOG(expiries_[e]);
        // we build a matrix with just the valid expiries
        blackVolMatrix = Matrix(validExpiryIdx.size(), config->deltas().size());
        for (Size i = 0; i < validExpiryIdx.size(); i++) {
            for (Size j = 0; j < deltaNames.size(); ++j) {
                blackVolMatrix[i][j] = tmpMatrix[validExpiryIdx[i]][j];
            }
        }
 
    } else {
        expiries_ = parseVectorOfValues<Period>(expiriesNoDuplicates_, &parsePeriod);
        unsortedExp = parseVectorOfValues<Period>(expiriesNoDuplicates_, &parsePeriod);
        std::sort(expiries_.begin(), expiries_.end());
 
        blackVolMatrix = Matrix(expiries_.size(), config->deltas().size());
        for (Size i = 0; i < expiries_.size(); i++) {
            Size idx = std::find(unsortedExp.begin(), unsortedExp.end(), expiries_[i]) - unsortedExp.begin();
            string e = expiriesNoDuplicates_[idx];
            dates.push_back(cal.advance(asof, expiries_[i]));
            for (Size j = 0; j < deltaNames.size(); ++j) {
                string qs = base + e + "/" + deltaNames[j];
                QuantLib::ext::shared_ptr<MarketDatum> md = loader.get(qs, asof);
                QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
                QL_REQUIRE(q, "quote not found, " << qs);
                blackVolMatrix[i][j] = q->quote()->value();
            }
        }
    }
 
    QuantExt::InterpolatedSmileSection::InterpolationMethod interp;
    if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Linear)
        interp = QuantExt::InterpolatedSmileSection::InterpolationMethod::Linear;
    else if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Cubic)
        interp = QuantExt::InterpolatedSmileSection::InterpolationMethod::CubicSpline;
    else {
        QL_FAIL("Delta FX vol surface: invalid interpolation, expected Linear, Cubic");
    }
 
    bool flatExtrapolation = true;
    auto smileExtrapType = parseExtrapolation(config->smileExtrapolation());
    if (smileExtrapType == Extrapolation::UseInterpolator) {
        DLOG("Smile extrapolation switched to using interpolator.");
        flatExtrapolation = false;
    } else if (smileExtrapType == Extrapolation::None) {
        DLOG("Smile extrapolation cannot be turned off on its own so defaulting to flat.");
    } else if (smileExtrapType == Extrapolation::Flat) {
        DLOG("Smile extrapolation has been set to flat.");
    } else {
        DLOG("Smile extrapolation " << smileExtrapType << " not expected so defaulting to flat.");
    }
 
    // daycounter used for interpolation in time.
    // TODO: push into conventions or config
    DayCounter dc = config->dayCounter();
    std::vector<Real> putDeltasNum, callDeltasNum;
    std::transform(putDeltas.begin(), putDeltas.end(), std::back_inserter(putDeltasNum),
                   [](const std::pair<Real, string>& x) { return x.first; });
    std::transform(callDeltas.begin(), callDeltas.end(), std::back_inserter(callDeltasNum),
                   [](const std::pair<Real, string>& x) { return x.first; });
    vol_ = QuantLib::ext::make_shared<QuantExt::BlackVolatilitySurfaceDelta>(
        asof, dates, putDeltasNum, callDeltasNum, hasATM, blackVolMatrix, dc, cal, fxSpot_, domYts_, forYts_,
        deltaType_, atmType_, boost::none, switchTenor_, longTermDeltaType_, longTermAtmType_, boost::none, interp,
        flatExtrapolation);
 
    vol_->enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildSmileBfRrCurve()

void buildSmileBfRrCurve ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig >  config, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Definition at line 249 of file fxvolcurve.cpp.

                                                                                                        {
 
    // collect relevant market data and populate expiries (as per regex or configured list)
 
    std::set<Period> expiriesTmp;
 
    std::vector<QuantLib::ext::shared_ptr<FXOptionQuote>> data;
    std::ostringstream ss;
    ss << MarketDatum::InstrumentType::FX_OPTION << "/RATE_LNVOL/" << spec.unitCcy()<< "/"
        << spec.ccy()<< "/*";
    Wildcard w(ss.str());
    for (const auto& md : loader.get(w, asof)) {
        QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
        QL_REQUIRE(q, "Internal error: could not downcast MarketDatum '" << md->name() << "' to FXOptionQuote");
        QL_REQUIRE(q->unitCcy() == spec.unitCcy(),
            "FXOptionQuote unit ccy '" << q->unitCcy() << "' <> FXVolatilityCurveSpec unit ccy '" << spec.unitCcy() << "'");
        QL_REQUIRE(q->ccy() == spec.ccy(),
            "FXOptionQuote ccy '" << q->ccy() << "' <> FXVolatilityCurveSpec ccy '" << spec.ccy() << "'");
        Strike s = parseStrike(q->strike());
        if (s.type == Strike::Type::BF || s.type == Strike::Type::RR || s.type == Strike::Type::ATM) {
            vector<string> tokens;
            boost::split(tokens, md->name(), boost::is_any_of("/"));
            QL_REQUIRE(tokens.size() == 6, "6 tokens expected in " << md->name());
            if (expiriesWildcard_ && expiriesWildcard_->matches(tokens[4]))
                expiriesTmp.insert(q->expiry());
            data.push_back(q);
        }
    }
 
    if (!expiriesWildcard_) {
        auto tmp = parseVectorOfValues<Period>(expiriesNoDuplicates_, &parsePeriod);
        expiriesTmp = std::set<Period>(tmp.begin(), tmp.end());
    }
 
    // populate quotes
 
    std::vector<Size> smileDeltas = config->smileDelta();
    std::sort(smileDeltas.begin(), smileDeltas.end());
 
    std::vector<std::vector<Real>> bfQuotesTmp(expiriesTmp.size(), std::vector<Real>(smileDeltas.size(), Null<Real>()));
    std::vector<std::vector<Real>> rrQuotesTmp(expiriesTmp.size(), std::vector<Real>(smileDeltas.size(), Null<Real>()));
    std::vector<Real> atmQuotesTmp(expiriesTmp.size(), Null<Real>());
 
    for (auto const& q : data) {
        Size expiryIdx = std::distance(expiriesTmp.begin(), expiriesTmp.find(q->expiry()));
        if (expiryIdx >= expiriesTmp.size())
            continue;
        Strike s = parseStrike(q->strike());
        if (s.type == Strike::Type::ATM) {
            atmQuotesTmp[expiryIdx] = q->quote()->value();
        } else {
            Size deltaIdx = std::distance(smileDeltas.begin(), std::find(smileDeltas.begin(), smileDeltas.end(),
                                                                         static_cast<Size>(s.value + 0.5)));
            if (deltaIdx >= smileDeltas.size())
                continue;
            if (s.type == Strike::Type::BF) {
                bfQuotesTmp[expiryIdx][deltaIdx] = q->quote()->value();
            } else if (s.type == Strike::Type::RR) {
                rrQuotesTmp[expiryIdx][deltaIdx] = q->quote()->value();
            }
        }
    }
 
    // identify the rows with complete data
 
    std::vector<bool> dataComplete(expiriesTmp.size(), true);
 
    for (Size i = 0; i < expiriesTmp.size(); ++i) {
        for (Size j = 0; j < smileDeltas.size(); ++j) {
            if (bfQuotesTmp[i][j] == Null<Real>() || rrQuotesTmp[i][j] == Null<Real>() ||
                atmQuotesTmp[i] == Null<Real>())
                dataComplete[i] = false;
        }
    }
 
    // if we have an explicitly configured expiry list, we require that the data is complete for all expiries
 
    if (!expiriesWildcard_) {
        Size i = 0;
        for (auto const& e : expiriesTmp) {
            QL_REQUIRE(dataComplete[i++], "BFRR FX vol surface: incomplete data for expiry " << e);
        }
    }
 
    // build the final quotes for the expiries that have complete data
 
    Size i = 0;
    for (auto const& e : expiriesTmp) {
        if (dataComplete[i++]) {
            expiries_.push_back(e);
            TLOG("adding expiry " << e << " with complete data");
        } else {
            TLOG("removing expiry " << e << ", because data is not complete");
        }
    }
 
    std::vector<std::vector<Real>> bfQuotes(expiries_.size(), std::vector<Real>(smileDeltas.size()));
    std::vector<std::vector<Real>> rrQuotes(expiries_.size(), std::vector<Real>(smileDeltas.size()));
    std::vector<Real> atmQuotes(expiries_.size());
 
    Size row = 0;
    for (Size i = 0; i < expiriesTmp.size(); ++i) {
        if (!dataComplete[i])
            continue;
        atmQuotes[row] = atmQuotesTmp[i];
        for (Size j = 0; j < smileDeltas.size(); ++j) {
            bfQuotes[row][j] = bfQuotesTmp[i][j];
            rrQuotes[row][j] = rrQuotesTmp[i][j];
        }
        ++row;
    }
 
    // build BFRR surface
 
    DLOG("build BFRR fx vol surface with " << expiries_.size() << " expiries and " << smileDeltas.size()
                                           << " delta(s)");
 
    QuantExt::BlackVolatilitySurfaceBFRR::SmileInterpolation interp;
    if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Linear)
        interp = QuantExt::BlackVolatilitySurfaceBFRR::SmileInterpolation::Linear;
    else if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Cubic)
        interp = QuantExt::BlackVolatilitySurfaceBFRR::SmileInterpolation::Cubic;
    else {
        QL_FAIL("BFRR FX vol surface: invalid interpolation, expected Linear, Cubic");
    }
 
    std::vector<Date> dates;
    std::transform(expiries_.begin(), expiries_.end(), std::back_inserter(dates),
                   [&asof, &config](const Period& p) { return config->calendar().advance(asof, p); });
 
    std::vector<Real> smileDeltasScaled;
    std::transform(smileDeltas.begin(), smileDeltas.end(), std::back_inserter(smileDeltasScaled),
                   [](Size d) { return static_cast<Real>(d) / 100.0; });
 
    vol_ = QuantLib::ext::make_shared<QuantExt::BlackVolatilitySurfaceBFRR>(
        asof, dates, smileDeltasScaled, bfQuotes, rrQuotes, atmQuotes, config->dayCounter(), config->calendar(),
        fxSpot_, spotDays_, spotCalendar_, domYts_, forYts_, deltaType_, atmType_, switchTenor_, longTermDeltaType_,
        longTermAtmType_, riskReversalInFavorOf_, butterflyIsBrokerStyle_, interp);
 
    vol_->enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildVannaVolgaOrATMCurve()

void buildVannaVolgaOrATMCurve ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig >  config, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Definition at line 393 of file fxvolcurve.cpp.

                                                                                                              {
 
    bool isATM = config->dimension() == FXVolatilityCurveConfig::Dimension::ATM;
    Natural smileDelta = 0;
    std::string deltaRr;
    std::string deltaBf;
    if (!isATM) {
        QL_REQUIRE(config->smileDelta().size() == 1,
                   "Exactly one SmileDelta required for VannaVolga Curve (got " << config->smileDelta().size() << ")");
        smileDelta = config->smileDelta().front();
        deltaRr = to_string(smileDelta) + "RR";
        deltaBf = to_string(smileDelta) + "BF";
    }
    // We loop over all market data, looking for quotes that match the configuration
    // every time we find a matching expiry we remove it from the list
    // we replicate this for all 3 types of quotes were applicable.
    Size n = isATM ? 1 : 3; // [0] = ATM, [1] = RR, [2] = BF
    vector<vector<QuantLib::ext::shared_ptr<FXOptionQuote>>> quotes(n);
 
    QL_REQUIRE(!expiriesWildcard_ || isATM, "wildcards only supported for ATM, Delta, BFRR FxVol Curves");
 
    vector<Period> cExpiries;
    vector<vector<Period>> expiries;
    // Create the regular expression
    if (!expiriesWildcard_) {
        cExpiries = parseVectorOfValues<Period>(expiriesNoDuplicates_, &parsePeriod);
        expiries = vector<vector<Period>>(n, cExpiries);
    }
 
    // Load the relevant quotes
    std::vector<QuantLib::ext::shared_ptr<FXOptionQuote>> data;
    std::ostringstream ss;
    ss << MarketDatum::InstrumentType::FX_OPTION << "/RATE_LNVOL/" << spec.unitCcy()<< "/"
        << spec.ccy()<< "/*";
    Wildcard w(ss.str());
    for (const auto& md : loader.get(w, asof)) {
 
        QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
        QL_REQUIRE(q, "Internal error: could not downcast MarketDatum '" << md->name() << "' to FXOptionQuote");
        QL_REQUIRE(q->unitCcy() == spec.unitCcy(),
            "FXOptionQuote unit ccy '" << q->unitCcy() << "' <> FXVolatilityCurveSpec unit ccy '" << spec.unitCcy() << "'");
        QL_REQUIRE(q->ccy() == spec.ccy(),
            "FXOptionQuote ccy '" << q->ccy() << "' <> FXVolatilityCurveSpec ccy '" << spec.ccy() << "'");
 
 
        Size idx = 999999;
        if (q->strike() == "ATM")
            idx = 0;
        else if (!isATM && q->strike() == deltaRr)
            idx = 1;
        else if (!isATM && q->strike() == deltaBf)
            idx = 2;
 
        // silently skip unknown strike strings
        if ((isATM && idx == 0) || (!isATM && idx <= 2)) {
            if (expiriesWildcard_) {
                vector<string> tokens;
                boost::split(tokens, md->name(), boost::is_any_of("/"));
                QL_REQUIRE(tokens.size() == 6, "6 tokens expected in " << md->name());
                if (expiriesWildcard_->matches(tokens[4])) {
                    quotes[idx].push_back(q);
                }
            } else {
                auto it = std::find(expiries[idx].begin(), expiries[idx].end(), q->expiry());
                if (it != expiries[idx].end()) {
                    // we have a hit
                    quotes[idx].push_back(q);
                    // remove it from the list
                    expiries[idx].erase(it);
                }
 
                // check if we are done
                // for ATM we just check expiries[0], otherwise we check all 3
                if (expiries[0].empty() && (isATM || (expiries[1].empty() && expiries[2].empty())))
                    break;
            }
        }
    }
 
    // Check ATM first
    // Check that we have all the expiries we need
    LOG("FXVolCurve: read " << quotes[0].size() << " ATM vols");
    if (!expiriesWildcard_) {
        QL_REQUIRE(expiries[0].size() == 0,
                   "No ATM quote found for spec " << spec << " with expiry " << expiries[0].front());
    }
 
    QL_REQUIRE(quotes[0].size() > 0, "No ATM quotes found for spec " << spec);
    // No check the rest
    if (!isATM) {
        LOG("FXVolCurve: read " << quotes[1].size() << " RR and " << quotes[2].size() << " BF quotes");
        QL_REQUIRE(expiries[1].size() == 0,
                   "No RR quote found for spec " << spec << " with expiry " << expiries[1].front());
        QL_REQUIRE(expiries[2].size() == 0,
                   "No BF quote found for spec " << spec << " with expiry " << expiries[2].front());
    }
 
    // sort all quotes
    for (Size i = 0; i < n; i++) {
        std::sort(quotes[i].begin(), quotes[i].end(),
                  [](const QuantLib::ext::shared_ptr<FXOptionQuote>& a, const QuantLib::ext::shared_ptr<FXOptionQuote>& b) -> bool {
                      return a->expiry() < b->expiry();
                  });
    }
 
    // daycounter used for interpolation in time.
    // TODO: push into conventions or config
    DayCounter dc = config->dayCounter();
    Calendar cal = config->calendar();
 
    // build vol curve
    if (isATM && quotes[0].size() == 1) {
        vol_ = QuantLib::ext::shared_ptr<BlackVolTermStructure>(
            new BlackConstantVol(asof, config->calendar(), quotes[0].front()->quote()->value(), dc));
        expiries_ = {quotes[0].front()->expiry()};
    } else {
 
        Size numExpiries = quotes[0].size();
        vector<Date> dates(numExpiries);
        vector<vector<Volatility>> vols(n, vector<Volatility>(numExpiries)); // same as above: [0] = ATM, etc.
 
        for (Size i = 0; i < numExpiries; i++) {
            dates[i] = cal.advance(asof, quotes[0][i]->expiry());
            expiries_.push_back(quotes[0][i]->expiry());
            DLOG("Spec Tenor Vol Variance");
            for (Size idx = 0; idx < n; idx++) {
                vols[idx][i] = quotes[idx][i]->quote()->value();
                Real variance = vols[idx][i] * vols[idx][i] * (dates[i] - asof) / 365.0; // approximate variance
                DLOG(spec << " " << quotes[0][i]->expiry() << " " << vols[idx][i] << " " << variance);
            }
        }
 
        if (isATM) {
            // ATM
            // Set forceMonotoneVariance to false - allowing decreasing variance
            vol_ = QuantLib::ext::shared_ptr<BlackVolTermStructure>(new BlackVarianceCurve(asof, dates, vols[0], dc, false));
        } else {
            // Smile
            bool vvFirstApprox = false; // default to VannaVolga second approximation
            if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::VannaVolga1) {
                vvFirstApprox = true;
            }
 
            vol_ = QuantLib::ext::make_shared<QuantExt::FxBlackVannaVolgaVolatilitySurface>(
                asof, dates, vols[0], vols[1], vols[2], dc, cal, fxSpot_, domYts_, forYts_, false, vvFirstApprox,
                atmType_, deltaType_, smileDelta / 100.0, switchTenor_, longTermAtmType_, longTermDeltaType_);
        }
    }
    vol_->enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildSmileAbsoluteCurve()

void buildSmileAbsoluteCurve ( Date  asof, FXVolatilityCurveSpec  spec, const Loader &  loader, QuantLib::ext::shared_ptr< FXVolatilityCurveConfig >  config, const FXTriangulation &  fxSpots, const map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Definition at line 547 of file fxvolcurve.cpp.

                                                                                                            {
 
    // collect relevant market data and populate expiries (as per regex or configured list)
    std::set<Period> expiriesTmp;
 
    std::vector<QuantLib::ext::shared_ptr<FXOptionQuote>> data;
    std::ostringstream ss;
    ss << MarketDatum::InstrumentType::FX_OPTION << "/RATE_LNVOL/" << spec.unitCcy() << "/" << spec.ccy() << "/*";
    Wildcard w(ss.str());
    for (const auto& md : loader.get(w, asof)) {
        QuantLib::ext::shared_ptr<FXOptionQuote> q = QuantLib::ext::dynamic_pointer_cast<FXOptionQuote>(md);
        QL_REQUIRE(q, "Internal error: could not downcast MarketDatum '" << md->name() << "' to FXOptionQuote");
        QL_REQUIRE(q->unitCcy() == spec.unitCcy(), "FXOptionQuote unit ccy '" << q->unitCcy()
                                                                              << "' <> FXVolatilityCurveSpec unit ccy '"
                                                                              << spec.unitCcy() << "'");
        QL_REQUIRE(q->ccy() == spec.ccy(),
                   "FXOptionQuote ccy '" << q->ccy() << "' <> FXVolatilityCurveSpec ccy '" << spec.ccy() << "'");
        Strike s = parseStrike(q->strike());
        if (s.type == Strike::Type::Absolute) {
            vector<string> tokens;
            boost::split(tokens, md->name(), boost::is_any_of("/"));
            QL_REQUIRE(tokens.size() == 6, "6 tokens expected in " << md->name());
            if (expiriesWildcard_ && expiriesWildcard_->matches(tokens[4]))
                expiriesTmp.insert(q->expiry());
            data.push_back(q);
        }
    }
 
    if (!expiriesWildcard_) {
        auto tmp = parseVectorOfValues<Period>(expiriesNoDuplicates_, &parsePeriod);
        expiriesTmp = std::set<Period>(tmp.begin(), tmp.end());
    }
 
    // populate quotes
    std::vector<std::map<Real, Real>> strikeQuotesTmp(expiriesTmp.size());
 
    for (auto const& q : data) {
        Size expiryIdx = std::distance(expiriesTmp.begin(), expiriesTmp.find(q->expiry()));
        if (expiryIdx >= expiriesTmp.size())
            continue;
        Strike s = parseStrike(q->strike());
        // If the strike for expirtIdx does not exist, read in the quote
        if (strikeQuotesTmp[expiryIdx].count(s.value) == 0)
            strikeQuotesTmp[expiryIdx][s.value] = q->quote()->value();
    }
 
    // identify the expiries with at least one strike quote
    std::vector<bool> dataComplete(expiriesTmp.size(), true);
 
    for (Size i = 0; i < expiriesTmp.size(); ++i) {
        if (strikeQuotesTmp[i].empty())
            dataComplete[i] = false;
    }
 
    // if we have an explicitly configured expiry list, we require that there is at least one strike quote for all expiries
 
    if (!expiriesWildcard_) {
        Size i = 0;
        for (auto const& e : expiriesTmp) {
            QL_REQUIRE(dataComplete[i++], "Absolute FX vol surface: missing data for expiry " << e);
        }
    }
 
    // build the final quotes for the expiries that have complete data
    Size i = 0;
    for (auto const& e : expiriesTmp) {
        if (dataComplete[i++]) {
            expiries_.push_back(e);
            TLOG("adding expiry " << e << " with at least one strike quote");
        } else {
            TLOG("removing expiry " << e << ", no strike quote found");
        }
    }
 
    std::vector<std::vector<Real>> strikeQuotes, strikes;
    std::vector<Real> strikeQuote, strike;
 
    for (Size i = 0; i < expiriesTmp.size(); ++i) {
        if (!dataComplete[i])
            continue;
        for (auto const& quote : strikeQuotesTmp[i]) {
            strike.push_back(quote.first);
            strikeQuote.push_back(quote.second);
        }
        strikeQuotes.push_back(strikeQuote);
        strikes.push_back(strike);
        strikeQuote.clear();
        strike.clear();
    }
 
    // build Absolute surface
 
    DLOG("build Absolute fx vol surface with " << expiries_.size() << " expiries");
 
    QuantExt::BlackVolatilitySurfaceAbsolute::SmileInterpolation interp;
    if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Linear)
        interp = QuantExt::BlackVolatilitySurfaceAbsolute::SmileInterpolation::Linear;
    else if (config->smileInterpolation() == FXVolatilityCurveConfig::SmileInterpolation::Cubic)
        interp = QuantExt::BlackVolatilitySurfaceAbsolute::SmileInterpolation::Cubic;
    else {
        QL_FAIL("Absolute FX vol surface: invalid interpolation, expected Linear, Cubic");
    }
 
    std::vector<Date> dates;
    std::transform(expiries_.begin(), expiries_.end(), std::back_inserter(dates),
                   [&asof, &config](const Period& p) { return config->calendar().advance(asof, p); });
 
    vol_ = QuantLib::ext::make_shared<QuantExt::BlackVolatilitySurfaceAbsolute>(
        asof, dates, strikes, strikeQuotes, config->dayCounter(), config->calendar(),
        fxSpot_, spotDays_, spotCalendar_, domYts_, forYts_, deltaType_, atmType_, switchTenor_, longTermDeltaType_,
        longTermAtmType_, interp);
 
    vol_->enableExtrapolation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

spec_

FXVolatilityCurveSpec spec_

private

Definition at line 68 of file fxvolcurve.hpp.

vol_

QuantLib::ext::shared_ptr<BlackVolTermStructure> vol_

private

Definition at line 69 of file fxvolcurve.hpp.

fxSpot_

Handle<Quote> fxSpot_

private

Definition at line 70 of file fxvolcurve.hpp.

domYts_

Handle<YieldTermStructure> domYts_

private

Definition at line 71 of file fxvolcurve.hpp.

forYts_

Handle<YieldTermStructure> forYts_

private

Definition at line 71 of file fxvolcurve.hpp.

sourceCcy_

string sourceCcy_

private

Definition at line 72 of file fxvolcurve.hpp.

targetCcy_

string targetCcy_

private

Definition at line 72 of file fxvolcurve.hpp.

expiriesNoDuplicates_

std::vector<string> expiriesNoDuplicates_

private

Definition at line 73 of file fxvolcurve.hpp.

expiries_

std::vector<Period> expiries_

private

Definition at line 74 of file fxvolcurve.hpp.

expiriesWildcard_

boost::optional<Wildcard> expiriesWildcard_

private

Definition at line 75 of file fxvolcurve.hpp.

spotDays_

Size spotDays_

private

Definition at line 76 of file fxvolcurve.hpp.

spotCalendar_

Calendar spotCalendar_

private

Definition at line 77 of file fxvolcurve.hpp.

switchTenor_

QuantLib::Period switchTenor_

private

Definition at line 78 of file fxvolcurve.hpp.

atmType_

QuantLib::DeltaVolQuote::AtmType atmType_

private

Definition at line 79 of file fxvolcurve.hpp.

deltaType_

QuantLib::DeltaVolQuote::DeltaType deltaType_

private

Definition at line 80 of file fxvolcurve.hpp.

longTermAtmType_

QuantLib::DeltaVolQuote::AtmType longTermAtmType_

private

Definition at line 81 of file fxvolcurve.hpp.

longTermDeltaType_

QuantLib::DeltaVolQuote::DeltaType longTermDeltaType_

private

Definition at line 82 of file fxvolcurve.hpp.

riskReversalInFavorOf_

QuantLib::Option::Type riskReversalInFavorOf_

private

Definition at line 83 of file fxvolcurve.hpp.

butterflyIsBrokerStyle_

bool butterflyIsBrokerStyle_

private

Definition at line 84 of file fxvolcurve.hpp.

calibrationInfo_

QuantLib::ext::shared_ptr<FxEqCommVolCalibrationInfo> calibrationInfo_

private

Definition at line 86 of file fxvolcurve.hpp.