Merge branch 'bugfix/QPR-13765' into 'master'

damienbarker · damienbarker · commit 76eb9fbad368 · 2026-01-15T10:07:21.000Z
Resolve QPR-13765 Bugfix normal vols broken in VaR or sensi if not using spreaded curves

Closes QPR-13765

See merge request qs/oreplus!3141
diff --git a/OREAnalytics/orea/scenario/scenariosimmarket.cpp b/OREAnalytics/orea/scenario/scenariosimmarket.cpp
@@ -3027,7 +3027,7 @@ ScenarioSimMarket::ScenarioSimMarket(
                                 } else {
                                     newVol = Handle<BlackVolTermStructure>(QuantLib::ext::make_shared<BlackVarianceCurve3>(
                                         0, NullCalendar(), baseVol->businessDayConvention(), dayCounter, expiryTimes,
-                                        quotes[0], false));
+                                        quotes[0], false, baseVol->volType(), baseVol->shift()));
                                 }
                             } else {
                                 DLOG("Ssm comm vol for " << name << " uses BlackVarianceSurfaceMoneynessSpot.");
@@ -3052,7 +3052,9 @@ ScenarioSimMarket::ScenarioSimMarket(
                                     newVol = Handle<BlackVolTermStructure>(
                                         QuantLib::ext::make_shared<BlackVarianceSurfaceMoneynessForward>(
                                             baseVol->calendar(), spot, expiryTimes, moneyness, quotes, dayCounter,
-                                            priceYts, yts, stickyStrike, flatExtrapMoneyness));
+                                            priceYts, yts, stickyStrike, flatExtrapMoneyness, BlackVolTimeExtrapolation::FlatVolatility,
+                                            baseVol->volType(),
+                                            baseVol->shift()));
                                 }
                             }
 
diff --git a/QuantExt/qle/termstructures/blackinvertedvoltermstructure.hpp b/QuantExt/qle/termstructures/blackinvertedvoltermstructure.hpp
@@ -41,7 +41,8 @@ class BlackInvertedVolTermStructure : public BlackVolTermStructure {
     /*! This will work with both a floating and fixed reference date underlying surface,
         since we are reimplementing the reference date and update methods */
     BlackInvertedVolTermStructure(const Handle<BlackVolTermStructure>& vol)
-        : BlackVolTermStructure(vol->businessDayConvention(), vol->dayCounter()), vol_(vol) {
+        : BlackVolTermStructure(vol->businessDayConvention(), vol->dayCounter(), vol->volType(), vol->shift()),
+          vol_(vol) {
         registerWith(vol_);
     }
 
diff --git a/QuantExt/qle/termstructures/blackvariancecurve3.cpp b/QuantExt/qle/termstructures/blackvariancecurve3.cpp
@@ -23,8 +23,9 @@ namespace QuantExt {
 
 BlackVarianceCurve3::BlackVarianceCurve3(Natural settlementDays, const Calendar& cal, BusinessDayConvention bdc,
                                          const DayCounter& dc, const std::vector<Time>& times,
-                                         const std::vector<Handle<Quote> >& blackVolCurve, bool requireMonotoneVariance)
-    : BlackVarianceTermStructure(settlementDays, cal, bdc, dc), times_(times), quotes_(blackVolCurve),
+                                         const std::vector<Handle<Quote> >& blackVolCurve, bool requireMonotoneVariance,
+                                         const VolatilityType type, const Real shift)
+    : BlackVarianceTermStructure(settlementDays, cal, bdc, dc, type, shift), times_(times), quotes_(blackVolCurve),
       requireMonotoneVariance_(requireMonotoneVariance) {
 
     QL_REQUIRE(times.size() == blackVolCurve.size(), "mismatch between date vector and black vol vector");
diff --git a/QuantExt/qle/termstructures/blackvariancecurve3.hpp b/QuantExt/qle/termstructures/blackvariancecurve3.hpp
@@ -49,7 +49,8 @@ class BlackVarianceCurve3 : public LazyObject, public BlackVarianceTermStructure
     // If requireMonotoneVariance is true, we check for monotone variance in performCalculations and throw if not
     BlackVarianceCurve3(Natural settlementDays, const Calendar& cal, BusinessDayConvention bdc, const DayCounter& dc,
                         const std::vector<Time>& times, const std::vector<Handle<Quote> >& blackVolCurve,
-                        bool requireMonotoneVariance = true);
+                        bool requireMonotoneVariance = true, const VolatilityType type = ShiftedLognormal, 
+                        const Real shift = 0.0);
     //! \name TermStructure interface
     //@{
     Date maxDate() const override;
diff --git a/QuantExt/qle/termstructures/blackvariancesurfacemoneyness.cpp b/QuantExt/qle/termstructures/blackvariancesurfacemoneyness.cpp
@@ -31,8 +31,8 @@ namespace QuantExt {
 BlackVarianceSurfaceMoneyness::BlackVarianceSurfaceMoneyness(
     const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times, const std::vector<Real>& moneyness,
     const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix, const DayCounter& dayCounter, bool stickyStrike,
-    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation)
-    : BlackVarianceTermStructure(0, cal, Following, dayCounter), stickyStrike_(stickyStrike), spot_(spot),
+    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation, const VolatilityType type, const Real shift)
+    : BlackVarianceTermStructure(0, cal, Following, dayCounter, type, shift), stickyStrike_(stickyStrike), spot_(spot),
       times_(times), moneyness_(moneyness), flatExtrapMoneyness_(flatExtrapMoneyness),
       timeExtrapolation_(timeExtrapolation), quotes_(blackVolMatrix) {
     init();
@@ -42,8 +42,9 @@ BlackVarianceSurfaceMoneyness::BlackVarianceSurfaceMoneyness(
     const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times,
     const std::vector<Real>& moneyness, const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix,
     const DayCounter& dayCounter, bool stickyStrike, bool flatExtrapMoneyness,
-    BlackVolTimeExtrapolation timeExtrapolation)
-    : BlackVarianceTermStructure(referenceDate, cal, Following, dayCounter), stickyStrike_(stickyStrike), spot_(spot),
+    BlackVolTimeExtrapolation timeExtrapolation, const VolatilityType type, const Real shift)
+    : BlackVarianceTermStructure(referenceDate, cal, Following, dayCounter, type, shift), 
+      stickyStrike_(stickyStrike), spot_(spot),
       times_(times), moneyness_(moneyness), flatExtrapMoneyness_(flatExtrapMoneyness),
       timeExtrapolation_(timeExtrapolation), quotes_(blackVolMatrix) {
     init();
@@ -126,16 +127,17 @@ Real BlackVarianceSurfaceMoneyness::blackVarianceMoneyness(Time t, Real m) const
 BlackVarianceSurfaceMoneynessSpot::BlackVarianceSurfaceMoneynessSpot(
     const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times, const std::vector<Real>& moneyness,
     const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix, const DayCounter& dayCounter, bool stickyStrike,
-    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation)
+    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation, const VolatilityType type, const Real shift)
     : BlackVarianceSurfaceMoneyness(cal, spot, times, moneyness, blackVolMatrix, dayCounter, stickyStrike,
-                                    flatExtrapMoneyness, timeExtrapolation) {}
+                                    flatExtrapMoneyness, timeExtrapolation, type, shift) {}
 
 BlackVarianceSurfaceMoneynessSpot::BlackVarianceSurfaceMoneynessSpot(
     const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times,
     const std::vector<Real>& moneyness, const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix,
-    const DayCounter& dayCounter, bool stickyStrike, bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation)
+    const DayCounter& dayCounter, bool stickyStrike, bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation,
+    const VolatilityType type, const Real shift)
     : BlackVarianceSurfaceMoneyness(referenceDate, cal, spot, times, moneyness, blackVolMatrix, dayCounter,
-                                    stickyStrike, flatExtrapMoneyness, timeExtrapolation) {}
+                                    stickyStrike, flatExtrapMoneyness, timeExtrapolation, type, shift) {}
 
 Real BlackVarianceSurfaceMoneynessSpot::moneyness(Time, Real strike) const {
     if (strike == Null<Real>() || strike == 0) {
@@ -157,9 +159,9 @@ BlackVarianceSurfaceMoneynessForward::BlackVarianceSurfaceMoneynessForward(
     const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times, const std::vector<Real>& moneyness,
     const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix, const DayCounter& dayCounter,
     const Handle<YieldTermStructure>& forTS, const Handle<YieldTermStructure>& domTS, bool stickyStrike,
-    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation)
+    bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation, const VolatilityType type, const Real shift)
     : BlackVarianceSurfaceMoneyness(cal, spot, times, moneyness, blackVolMatrix, dayCounter, stickyStrike,
-                                    flatExtrapMoneyness, timeExtrapolation),
+                                    flatExtrapMoneyness, timeExtrapolation, type, shift),
       forTS_(forTS), domTS_(domTS) {
     init();
 }
@@ -168,9 +170,10 @@ BlackVarianceSurfaceMoneynessForward::BlackVarianceSurfaceMoneynessForward(
     const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times,
     const std::vector<Real>& moneyness, const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix,
     const DayCounter& dayCounter, const Handle<YieldTermStructure>& forTS, const Handle<YieldTermStructure>& domTS,
-    bool stickyStrike, bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation)
+    bool stickyStrike, bool flatExtrapMoneyness, BlackVolTimeExtrapolation timeExtrapolation,
+    const VolatilityType type, const Real shift)
     : BlackVarianceSurfaceMoneyness(referenceDate, cal, spot, times, moneyness, blackVolMatrix, dayCounter,
-                                    stickyStrike, flatExtrapMoneyness, timeExtrapolation),
+                                    stickyStrike, flatExtrapMoneyness, timeExtrapolation, type, shift),
       forTS_(forTS), domTS_(domTS) {
     init();
 }
diff --git a/QuantExt/qle/termstructures/blackvariancesurfacemoneyness.hpp b/QuantExt/qle/termstructures/blackvariancesurfacemoneyness.hpp
@@ -52,14 +52,18 @@ class BlackVarianceSurfaceMoneyness : public LazyObject, public BlackVarianceTer
                                   const std::vector<Real>& moneyness,
                                   const std::vector<std::vector<Handle<Quote> > >& blackVolMatrix,
                                   const DayCounter& dayCounter, bool stickyStrike, bool flatExtrapMoneyness = false, 
-                                  BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                  BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                  const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                  const Real shift = 0.0);
 
     //! Moneyness variance surface with a fixed reference date.
     BlackVarianceSurfaceMoneyness(const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot,
                                   const std::vector<Time>& times, const std::vector<Real>& moneyness,
                                   const std::vector<std::vector<Handle<Quote> > >& blackVolMatrix,
                                   const DayCounter& dayCounter, bool stickyStrike, bool flatExtrapMoneyness = false, 
-                                  BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                  BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                  const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                  const Real shift = 0.0);
 
     //! \name TermStructure interface
     //@{
@@ -129,15 +133,19 @@ class BlackVarianceSurfaceMoneynessSpot : public BlackVarianceSurfaceMoneyness {
                                       const std::vector<std::vector<Handle<Quote> > >& blackVolMatrix,
                                       const DayCounter& dayCounter, bool stickyStrike = false,
                                       bool flatExtrapMoneyness = false, 
-                                      BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                      BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                      const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                      const Real shift = 0.0);
 
     //! Spot moneyness variance surface with a fixed reference date.
     BlackVarianceSurfaceMoneynessSpot(const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot,
                                       const std::vector<Time>& times, const std::vector<Real>& moneyness,
                                       const std::vector<std::vector<Handle<Quote> > >& blackVolMatrix,
                                       const DayCounter& dayCounter, bool stickyStrike = false,
                                       bool flatExtrapMoneyness = false, 
-                                      BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                      BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                      const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                      const Real shift = 0.0);
 
 private:
     virtual Real moneyness(Time t, Real strike) const override;
@@ -154,7 +162,9 @@ class BlackVarianceSurfaceMoneynessForward : public BlackVarianceSurfaceMoneynes
                                          const DayCounter& dayCounter, const Handle<YieldTermStructure>& forTS,
                                          const Handle<YieldTermStructure>& domTS, bool stickyStrike = false,
                                          bool flatExtrapMoneyness = false, 
-                                         BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                         BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                         const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                         const Real shift = 0.0);
 
     //! Forward moneyness variance surface with a fixed reference date.
     BlackVarianceSurfaceMoneynessForward(const Date& referenceDate, const Calendar& cal, const Handle<Quote>& spot,
@@ -163,7 +173,9 @@ class BlackVarianceSurfaceMoneynessForward : public BlackVarianceSurfaceMoneynes
                                          const DayCounter& dayCounter, const Handle<YieldTermStructure>& forTS,
                                          const Handle<YieldTermStructure>& domTS, bool stickyStrike = false,
                                          bool flatExtrapMoneyness = false, 
-                                         BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
+                                         BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                         const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                         const Real shift = 0.0);
 
 private:
     // Shared initialisation
diff --git a/QuantExt/qle/termstructures/blackvariancesurfacestddevs.cpp b/QuantExt/qle/termstructures/blackvariancesurfacestddevs.cpp
@@ -28,9 +28,11 @@ namespace QuantExt {
 BlackVarianceSurfaceStdDevs::BlackVarianceSurfaceStdDevs(
     const Calendar& cal, const Handle<Quote>& spot, const std::vector<Time>& times, const std::vector<Real>& stdDevs,
     const std::vector<std::vector<Handle<Quote>>>& blackVolMatrix, const DayCounter& dayCounter,
-    const QuantLib::ext::shared_ptr<EqFxIndexBase>& index, bool stickyStrike, bool flatExtrapMoneyness)
-    : BlackVarianceSurfaceMoneyness(cal, spot, times, stdDevs, blackVolMatrix, dayCounter, stickyStrike), index_(index),
-      flatExtrapolateMoneyness_(flatExtrapMoneyness) {
+    const QuantLib::ext::shared_ptr<EqFxIndexBase>& index, bool stickyStrike, bool flatExtrapMoneyness,
+    BlackVolTimeExtrapolation timeExtrapolation, const VolatilityType type, const Real shift)
+    : BlackVarianceSurfaceMoneyness(cal, spot, times, stdDevs, blackVolMatrix, dayCounter, stickyStrike,
+                                    flatExtrapMoneyness, timeExtrapolation, type, shift),
+      index_(index), flatExtrapolateMoneyness_(flatExtrapMoneyness) {
 
     // set up atm variance curve - maybe just take ATM vols in
     vector<Real>::const_iterator it = find(stdDevs.begin(), stdDevs.end(), 0.0);
diff --git a/QuantExt/qle/termstructures/blackvariancesurfacestddevs.hpp b/QuantExt/qle/termstructures/blackvariancesurfacestddevs.hpp
@@ -43,7 +43,10 @@ class BlackVarianceSurfaceStdDevs : public BlackVarianceSurfaceMoneyness {
                                 const std::vector<Real>& stdDevs,
                                 const std::vector<std::vector<Handle<Quote> > >& blackVolMatrix,
                                 const DayCounter& dayCounter, const QuantLib::ext::shared_ptr<EqFxIndexBase>& index,
-                                bool stickyStrike = false, bool flatExtrapMoneyness = false);
+                                bool stickyStrike = false, bool flatExtrapMoneyness = false,
+                                BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility,
+                                const VolatilityType type = VolatilityType::ShiftedLognormal,
+                                const Real shift = 0.0);
 
     // A method that takes a reference to a vector of vector of quotes (that will be populated), termstructure,
     // expiry times, and standard deviation points. Fills the quotes with the correct points from the termstructure.
diff --git a/QuantExt/qle/termstructures/blackvolconstantspread.cpp b/QuantExt/qle/termstructures/blackvolconstantspread.cpp
@@ -24,8 +24,9 @@ namespace QuantExt {
 
 BlackVolatilityConstantSpread::BlackVolatilityConstantSpread(const Handle<BlackVolTermStructure>& atm,
                                                              const Handle<BlackVolTermStructure>& surface)
-    : BlackVolTermStructure(0, atm->calendar(), atm->businessDayConvention(), atm->dayCounter()), atm_(atm),
-      surface_(surface) {
+    : BlackVolTermStructure(0, atm->calendar(), atm->businessDayConvention(), atm->dayCounter(), atm->volType(),
+                            atm->shift()),
+      atm_(atm), surface_(surface) {
     enableExtrapolation(atm->allowsExtrapolation());
     registerWith(atm);
     registerWith(surface);
diff --git a/QuantExt/qle/termstructures/blackvolsurfaceproxy.cpp b/QuantExt/qle/termstructures/blackvolsurfaceproxy.cpp
@@ -27,7 +27,7 @@ BlackVolatilitySurfaceProxy::BlackVolatilitySurfaceProxy(
     const QuantLib::ext::shared_ptr<EqFxIndexBase>& proxyIndex, const QuantLib::ext::shared_ptr<BlackVolTermStructure>& fxSurface,
     const QuantLib::ext::shared_ptr<FxIndex>& fxIndex, const QuantLib::ext::shared_ptr<CorrelationTermStructure>& correlation)
     : BlackVolatilityTermStructure(0, proxySurface->calendar(), proxySurface->businessDayConvention(),
-                                   proxySurface->dayCounter()),
+                                   proxySurface->dayCounter(), proxySurface->volType(), proxySurface->shift()),
       proxySurface_(proxySurface), index_(index), proxyIndex_(proxyIndex), fxSurface_(fxSurface), 
       fxIndex_(fxIndex), correlation_(correlation) {
 

Original file line number	Diff line number	Diff line change
`@@ -3027,7 +3027,7 @@ ScenarioSimMarket::ScenarioSimMarket(`
`3027`	`3027`	`} else {`
`3028`	`3028`	`newVol = Handle<BlackVolTermStructure>(QuantLib::ext::make_shared<BlackVarianceCurve3>(`
`3029`	`3029`	`0, NullCalendar(), baseVol->businessDayConvention(), dayCounter, expiryTimes,`
`3030`		`- quotes[0], false));`
	`3030`	`+ quotes[0], false, baseVol->volType(), baseVol->shift()));`
`3031`	`3031`	`}`
`3032`	`3032`	`} else {`
`3033`	`3033`	`DLOG("Ssm comm vol for " << name << " uses BlackVarianceSurfaceMoneynessSpot.");`
`@@ -3052,7 +3052,9 @@ ScenarioSimMarket::ScenarioSimMarket(`
`3052`	`3052`	`newVol = Handle<BlackVolTermStructure>(`
`3053`	`3053`	`QuantLib::ext::make_shared<BlackVarianceSurfaceMoneynessForward>(`
`3054`	`3054`	`baseVol->calendar(), spot, expiryTimes, moneyness, quotes, dayCounter,`
`3055`		`- priceYts, yts, stickyStrike, flatExtrapMoneyness));`
	`3055`	`+ priceYts, yts, stickyStrike, flatExtrapMoneyness, BlackVolTimeExtrapolation::FlatVolatility,`
	`3056`	`+ baseVol->volType(),`
	`3057`	`+ baseVol->shift()));`
`3056`	`3058`	`}`
`3057`	`3059`	`}`
`3058`	`3060`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,8 @@ class BlackInvertedVolTermStructure : public BlackVolTermStructure {`
`41`	`41`	`/*! This will work with both a floating and fixed reference date underlying surface,`
`42`	`42`	`since we are reimplementing the reference date and update methods */`
`43`	`43`	`BlackInvertedVolTermStructure(const Handle<BlackVolTermStructure>& vol)`
`44`		`- : BlackVolTermStructure(vol->businessDayConvention(), vol->dayCounter()), vol_(vol) {`
	`44`	`+ : BlackVolTermStructure(vol->businessDayConvention(), vol->dayCounter(), vol->volType(), vol->shift()),`
	`45`	`+ vol_(vol) {`
`45`	`46`	`registerWith(vol_);`
`46`	`47`	`}`
`47`	`48`