QPR-12825 Add StickySABR sensitivity calculation for swaption, yield and capfloor vol

Author: alexchow-acadia

Docs/UserGuide/parameterisation/simulation.tex

@@ -665,15 +665,22 @@ \subsubsection{Market}\label{sec:sim_market}
 \item Extrapolation: This can be FlatFwd or FlatZero. If not given, the value defaults to FlatFwd.
 \end{itemize}
 
-For swap, yield, interest cap-floor, yoy inflation cap-floor, zc inflation cap-floor, cds, fx, equity, commodity
-volatilities the smile dynamics can be specified as shown in listing \ref{lst:smile_dynamics_configuration} for swap
+For swaption, yield, interest rate cap-floor, yoy inflation cap-floor, zc inflation cap-floor, cds, fx, equity, commodity
+volatilities the smile dynamics can be specified as shown in listing \ref{lst:smile_dynamics_configuration} for swaption
 vols. The empty key serves as a default configuration for all keys for which no own smile dynamics node is present. The
-allowed smile dynamics values are StickyStrike and StickyMoneyness. If not given, the smile dynamics defaults to
-StickyStrike.
+allowed smile dynamics values are StickyStrike, StickyMoneyness and StickySABR.
+If not given, the smile dynamics defaults to StickyStrike.
+
+Note that StickySABR is only available for swaption volatilities, yield volatilities and interest rate cap-floor volatilities,
+and can only be used if the corresponding T0 surface has been calibrated using a SABR model.
+The SABR volatility surface in the simulation market is recalibrated to the expiry/term/strike grid specified in the simulation
+configuration, using the initial SABR configuration from the T0 surface. Any subsequent recalibration will keep all SABR parameters
+except for $\alpha$ fixed.
 \begin{listing}
   \begin{minted}[fontsize=\footnotesize]{xml}
     <SmileDynamics key="">StickyStrike</SmileDynamics>
     <SmileDynamics key="EUR-ESTER">StickyMoneyness</SmileDynamics>
+    <SmileDynamics key="USD-SOFR-3M">StickySABR</SmileDynamics>
   \end{minted}
 \caption{Smile Configuration Node}
 \label{lst:smile_dynamics_configuration}

OREAnalytics/orea/scenario/scenariosimmarket.cpp

@@ -44,6 +44,13 @@ class ProxyOptionletVolatility : public QuantLib::OptionletVolatilityStructure {
     Real displacement() const override { return baseVol_->displacement(); }
     Calendar calendar() const override { return baseVol_->calendar(); }
 
+    const QuantLib::Handle<QuantLib::OptionletVolatilityStructure>& baseVol() const { return baseVol_; }
+    const QuantLib::ext::shared_ptr<QuantLib::IborIndex>& baseIndex() const { return baseIndex_; }
+    const QuantLib::ext::shared_ptr<QuantLib::IborIndex>& targetIndex() const { return targetIndex_; }
+    const QuantLib::Period& baseRateComputationPeriod() const { return baseRateComputationPeriod_; }
+    const QuantLib::Period& targetRateComputationPeriod() const { return targetRateComputationPeriod_; }
+    double scalingFactor() const { return scalingFactor_; }
+
 private:
     QuantLib::ext::shared_ptr<QuantLib::SmileSection> smileSectionImpl(const QuantLib::Date& optionDate) const override;
     QuantLib::ext::shared_ptr<QuantLib::SmileSection> smileSectionImpl(QuantLib::Time optionTime) const override;

QuantExt/qle/termstructures/proxyoptionletvolatility.hpp

@@ -32,6 +32,11 @@ ProxySwaptionVolatility::ProxySwaptionVolatility(const QuantLib::Handle<Swaption
     : SwaptionVolatilityStructure(baseVol->businessDayConvention(), baseVol->dayCounter()), baseVol_(baseVol),
       baseSwapIndexBase_(baseSwapIndexBase), baseShortSwapIndexBase_(baseShortSwapIndexBase),
       targetSwapIndexBase_(targetSwapIndexBase), targetShortSwapIndexBase_(targetShortSwapIndexBase) {
+    registerWith(baseVol_);
+    registerWith(baseSwapIndexBase_);
+    registerWith(baseShortSwapIndexBase_);
+    registerWith(targetSwapIndexBase_);
+    registerWith(targetShortSwapIndexBase_);
     enableExtrapolation(baseVol->allowsExtrapolation());
 }
 

QuantExt/qle/termstructures/proxyswaptionvolatility.cpp

@@ -45,6 +45,10 @@ class ProxySwaptionVolatility : public QuantLib::SwaptionVolatilityStructure {
 
     const QuantLib::Period& maxSwapTenor() const override { return baseVol_->maxSwapTenor(); }
 
+    QuantLib::Handle<QuantLib::SwaptionVolatilityStructure> baseVol() const { return baseVol_; }
+    QuantLib::ext::shared_ptr<QuantLib::SwapIndex> baseSwapIndexBase() const { return baseSwapIndexBase_; }
+    QuantLib::ext::shared_ptr<QuantLib::SwapIndex> baseShortSwapIndexBase() const { return baseShortSwapIndexBase_; }
+
 private:
     QuantLib::ext::shared_ptr<QuantLib::SmileSection> smileSectionImpl(const QuantLib::Date& optionDate,
                                                                const QuantLib::Period& swapTenor) const override;

QuantExt/qle/termstructures/proxyswaptionvolatility.hpp

@@ -759,4 +759,34 @@ Real SabrParametricVolatility::evaluate(const Real timeToExpiry, const Real unde
                    outputOptionType);
 }
 
+QuantLib::ext::shared_ptr<SabrParametricVolatility> SabrParametricVolatility::clone(
+    const std::vector<ParametricVolatility::MarketSmile>& marketSmiles,
+    const std::vector<ParameterCalibration>& calibrationTypes) const {
+
+    auto modelParameters = modelParameters_;
+
+    if (calibrationTypes.size() > 0) {
+        // If calibration types are provided, we need to adjust the model parameters accordingly
+        for (Size i = 0; i < timeToExpiries_.size(); ++i) {
+            const auto& tte = timeToExpiries_[i];
+            for (Size j = 0; j < underlyingLengths_.size(); ++j) {
+                const auto& ul = underlyingLengths_[j];
+                auto key = std::make_pair(tte, ul);
+                QL_REQUIRE(calibrationTypes.size() == modelParameters[key].size(),
+                           "SabrParametricVolatility::clone(): number of calibration types ("
+                               << calibrationTypes.size() << ") does not match number of model parameters ("
+                               << modelParameters[key].size() << ") for ("
+                               << tte << ", " << ul << ").");
+                for (Size k = 0; k < modelParameters[key].size(); ++k) {
+                    modelParameters[key][k].second = calibrationTypes[k];
+                }
+            }
+        }
+    }
+
+    return QuantLib::ext::make_shared<SabrParametricVolatility>(
+        modelVariant_, marketSmiles, marketModelType_, inputMarketQuoteType_, discountCurve_, modelParameters,
+        modelShifts_, maxCalibrationAttempts_, exitEarlyErrorThreshold_, maxAcceptableError_);
+}
+
 } // namespace QuantExt

QuantExt/qle/termstructures/sabrparametricvolatility.cpp

@@ -89,6 +89,10 @@ class SabrParametricVolatility final : public ParametricVolatility {
 
     const std::vector<CalibrationResult>& calibrationResults() const { return calibrationResults_; }
 
+    QuantLib::ext::shared_ptr<SabrParametricVolatility> clone(
+        const std::vector<ParametricVolatility::MarketSmile>& marketSmiles,
+        const std::vector<ParameterCalibration>& calibrationTypes) const;
+
 private:
     static constexpr double eps1 = .0000001;
     static constexpr double eps2 = .9999;

QuantExt/qle/termstructures/sabrparametricvolatility.hpp

@@ -55,7 +55,7 @@ class SabrStrippedOptionletAdapter : public QuantLib::OptionletVolatilityStructu
         const std::vector<std::vector<std::pair<Real, ParametricVolatility::ParameterCalibration>>>&
             initialModelParameters = {},
         const QuantLib::Size maxCalibrationAttempts = 10, const QuantLib::Real exitEarlyErrorThreshold = 0.005,
-        const QuantLib::Real maxAcceptableError = 0.05);
+        const QuantLib::Real maxAcceptableError = 0.05, bool stickySabr = false);
 
     /*! Constructor taking an explicit \p referenceDate and the term structure will therefore be not \e moving.
      */
@@ -105,6 +105,13 @@ class SabrStrippedOptionletAdapter : public QuantLib::OptionletVolatilityStructu
         calculate();
         return parametricVolatility_;
     }
+    QuantExt::SabrParametricVolatility::ModelVariant modelVariant() const { return modelVariant_; }
+    QuantLib::Real modelDisplacement() const { return modelDisplacement_; }
+    const std::vector<std::vector<std::pair<Real, ParametricVolatility::ParameterCalibration>>>&
+        initialModelParameters() const { return initialModelParameters_; }
+    QuantLib::Size maxCalibrationAttempts() const { return maxCalibrationAttempts_; }
+    QuantLib::Real exitEarlyErrorThreshold() const { return exitEarlyErrorThreshold_; }
+    QuantLib::Real maxAcceptableError() const { return maxAcceptableError_; }
     //@}
 
 protected:
@@ -130,6 +137,7 @@ class SabrStrippedOptionletAdapter : public QuantLib::OptionletVolatilityStructu
     QuantLib::Size maxCalibrationAttempts_;
     QuantLib::Real exitEarlyErrorThreshold_;
     QuantLib::Real maxAcceptableError_;
+    bool stickySabr_;
 
     //! State
     mutable std::map<Real, QuantLib::ext::shared_ptr<ParametricVolatilitySmileSection>> cache_;
@@ -145,13 +153,13 @@ SabrStrippedOptionletAdapter<TimeInterpolator>::SabrStrippedOptionletAdapter(
     const QuantLib::Real modelDisplacement,
     const std::vector<std::vector<std::pair<Real, ParametricVolatility::ParameterCalibration>>>& initialModelParameters,
     const QuantLib::Size maxCalibrationAttempts, const QuantLib::Real exitEarlyErrorThreshold,
-    const QuantLib::Real maxAcceptableError)
+    const QuantLib::Real maxAcceptableError, bool stickySabr)
     : OptionletVolatilityStructure(sob->settlementDays(), sob->calendar(), sob->businessDayConvention(),
                                    sob->dayCounter()),
       optionletBase_(sob), ti_(ti), modelVariant_(modelVariant), outputVolatilityType_(outputVolatilityType),
       outputDisplacement_(outputDisplacement), initialModelParameters_(initialModelParameters),
       maxCalibrationAttempts_(maxCalibrationAttempts), exitEarlyErrorThreshold_(exitEarlyErrorThreshold),
-      maxAcceptableError_(maxAcceptableError) {
+      maxAcceptableError_(maxAcceptableError), stickySabr_(stickySabr) {
     registerWith(optionletBase_);
 }
 
@@ -238,6 +246,14 @@ inline void SabrStrippedOptionletAdapter<TimeInterpolator>::performCalculations(
         }
     }
 
+    // For sticky SABR, we only need to re-imply the alpha parameter after initial calibration
+    if (stickySabr_) {
+        if (auto sabr = QuantLib::ext::dynamic_pointer_cast<SabrParametricVolatility>(parametricVolatility_)) {
+            parametricVolatility_ = sabr->clone(marketSmiles, {});
+            return;
+        }
+    }
+
     std::map<Real, Real> modelShift;
     if (modelDisplacement_ != Null<Real>()) {
         modelShift[Null<Real>()] = modelDisplacement_;
@@ -250,6 +266,18 @@ inline void SabrStrippedOptionletAdapter<TimeInterpolator>::performCalculations(
             : ParametricVolatility::MarketQuoteType::ShiftedLognormalVolatility,
         Handle<YieldTermStructure>(), modelParameters, modelShift, maxCalibrationAttempts_, exitEarlyErrorThreshold_,
         maxAcceptableError_);
+
+    // for sticky SABR, after initial calibration, we re-create parametric volatility with only alpha to be implied
+    // this ensures that basis between the two parametric volatilities is eliminated
+    if (stickySabr_) {
+        if (auto sabr = QuantLib::ext::dynamic_pointer_cast<SabrParametricVolatility>(parametricVolatility_)) {
+            parametricVolatility_ = sabr->clone(marketSmiles,
+                                                { ParametricVolatility::ParameterCalibration::Implied, 
+                                                  ParametricVolatility::ParameterCalibration::Fixed,
+                                                  ParametricVolatility::ParameterCalibration::Fixed, 
+                                                  ParametricVolatility::ParameterCalibration::Fixed });
+        }
+    }
 }
 
 template <class TimeInterpolator> inline void SabrStrippedOptionletAdapter<TimeInterpolator>::deepUpdate() {

QuantExt/qle/termstructures/sabrstrippedoptionletadapter.hpp

@@ -36,19 +36,27 @@ SwaptionSabrCube::SwaptionSabrCube(
         initialModelParameters,
     const std::vector<Real>& outputShift, const std::vector<Real>& modelShift,
     const QuantLib::Size maxCalibrationAttempts, const QuantLib::Real exitEarlyErrorThreshold,
-    const QuantLib::Real maxAcceptableError)
+    const QuantLib::Real maxAcceptableError, bool stickySabr)
     : SwaptionVolatilityCube(atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndexBase,
                              shortSwapIndexBase, false),
       atmOptionTenors_(atmOptionTenors), atmSwapTenors_(atmSwapTenors), modelVariant_(modelVariant),
       outputVolatilityType_(outputVolatilityType), initialModelParameters_(initialModelParameters),
       outputShift_(outputShift), modelShift_(modelShift), maxCalibrationAttempts_(maxCalibrationAttempts),
-      exitEarlyErrorThreshold_(exitEarlyErrorThreshold), maxAcceptableError_(maxAcceptableError) {
+      exitEarlyErrorThreshold_(exitEarlyErrorThreshold), maxAcceptableError_(maxAcceptableError), stickySabr_(stickySabr) {
 
     registerWith(atmVolStructure);
-
-    for (auto const& v : volSpreads)
-        for (auto const& s : v)
-            registerWith(s);
+    registerWith(swapIndexBase);
+    registerWith(shortSwapIndexBase);
+
+    if (stickySabr) {
+        for (auto const& v : volSpreads)
+            for (auto const& s : v)
+                unregisterWith(s);
+    } else {
+        for (auto const& v : volSpreads)
+            for (auto const& s : v)
+                registerWith(s);
+    }
 }
 
 namespace {
@@ -147,6 +155,14 @@ void SwaptionSabrCube::performCalculations() const {
         }
     }
 
+    // For sticky SABR, we only need to re-imply the alpha parameter after initial calibration
+    if (stickySabr_) {
+        if (auto sabr = QuantLib::ext::dynamic_pointer_cast<SabrParametricVolatility>(parametricVolatility_)) {
+            parametricVolatility_ = sabr->clone(marketSmiles, {});
+            return;
+        }
+    }
+
     std::map<Real, Real> modelShift;
     if (!modelShift_.empty()) {
         QL_REQUIRE(modelShift_.size() == allSwapTenors.size(),
@@ -164,6 +180,18 @@ void SwaptionSabrCube::performCalculations() const {
             : ParametricVolatility::MarketQuoteType::ShiftedLognormalVolatility,
         Handle<YieldTermStructure>(), modelParameters, modelShift, maxCalibrationAttempts_, exitEarlyErrorThreshold_,
         maxAcceptableError_);
+
+    // for sticky SABR, after initial calibration, we re-create parametric volatility with only alpha to be implied
+    // this ensures that basis between the two parametric volatilities is eliminated
+    if (stickySabr_) {
+        if (auto sabr = QuantLib::ext::dynamic_pointer_cast<SabrParametricVolatility>(parametricVolatility_)) {
+            parametricVolatility_ = sabr->clone(marketSmiles,
+                                                { ParametricVolatility::ParameterCalibration::Implied, 
+                                                  ParametricVolatility::ParameterCalibration::Fixed,
+                                                  ParametricVolatility::ParameterCalibration::Fixed, 
+                                                  ParametricVolatility::ParameterCalibration::Fixed });
+        }
+    }
 }
 
 VolatilityType SwaptionSabrCube::volatilityType() const {
@@ -191,7 +219,7 @@ QuantLib::ext::shared_ptr<SmileSection> SwaptionSabrCube::smileSectionImpl(Time
     return tmp;
 }
 
-QuantLib::ext::shared_ptr<ParametricVolatility> SwaptionSabrCube::parametricVolatility() const {
+const QuantLib::ext::shared_ptr<ParametricVolatility>& SwaptionSabrCube::parametricVolatility() const {
     calculate();
     return parametricVolatility_;
 }

QuantExt/qle/termstructures/swaptionsabrcube.cpp

@@ -50,14 +50,26 @@ class SwaptionSabrCube : public SwaptionVolatilityCube {
                      const std::vector<Real>& outputShift = {}, const std::vector<Real>& modelShift = {},
                      const QuantLib::Size maxCalibrationAttempts = 10,
                      const QuantLib::Real exitEarlyErrorThreshold = 0.005,
-                     const QuantLib::Real maxAcceptableError = 0.05);
+                     const QuantLib::Real maxAcceptableError = 0.05, bool stickySabr = false);
+    // LazyObject interface
     void performCalculations() const override;
-    QuantLib::ext::shared_ptr<SmileSection> smileSectionImpl(Time optionTime, Time swapLength) const override;
-
-    QuantLib::ext::shared_ptr<ParametricVolatility> parametricVolatility() const;
 
+    // SwaptionVolatilityStructure interface
+    QuantLib::ext::shared_ptr<SmileSection> smileSectionImpl(Time optionTime, Time swapLength) const override;
     VolatilityType volatilityType() const override;
 
+    // inspectors
+    const QuantLib::ext::shared_ptr<ParametricVolatility>& parametricVolatility() const;
+    QuantExt::SabrParametricVolatility::ModelVariant modelVariant() const { return modelVariant_; }
+    const std::map<std::pair<QuantLib::Period, QuantLib::Period>,
+             std::vector<std::pair<Real, ParametricVolatility::ParameterCalibration>>>&
+        initialModelParameters() const { return initialModelParameters_; }
+    const std::vector<Real>& outputShift() const { return outputShift_; }
+    const std::vector<Real>& modelShift() const { return modelShift_; }
+    QuantLib::Size maxCalibrationAttempts() const { return maxCalibrationAttempts_; }
+    QuantLib::Real exitEarlyErrorThreshold() const { return exitEarlyErrorThreshold_; }
+    QuantLib::Real maxAcceptableError() const { return maxAcceptableError_; }
+
 private:
     Real shiftImpl(Time optionTime, Time swapLength) const override;
 
@@ -76,6 +88,7 @@ class SwaptionSabrCube : public SwaptionVolatilityCube {
     QuantLib::Size maxCalibrationAttempts_;
     QuantLib::Real exitEarlyErrorThreshold_;
     QuantLib::Real maxAcceptableError_;
+    bool stickySabr_;
 };
 
 } // namespace QuantExt