QPR-12201 use swap index discount curve to build calibrating swaptions

Author: pcaspers

OREData/ored/model/lgmbuilder.cpp

@@ -32,9 +32,9 @@
 #include <ored/model/structuredmodelerror.hpp>
 #include <ored/model/utilities.hpp>
 #include <ored/utilities/dategrid.hpp>
+#include <ored/utilities/indexparser.hpp>
 #include <ored/utilities/log.hpp>
 #include <ored/utilities/parsers.hpp>
-#include <ored/utilities/indexparser.hpp>
 #include <ored/utilities/strike.hpp>
 
 using namespace QuantLib;
@@ -177,31 +177,30 @@ LgmBuilder::LgmBuilder(const boost::shared_ptr<ore::data::Market>& market, const
     string qualifier = data_->qualifier();
     currency_ = qualifier;
     boost::shared_ptr<IborIndex> index;
-    if(tryParseIborIndex(qualifier,index)) {
-	currency_ = index->currency().code();
+    if (tryParseIborIndex(qualifier, index)) {
+        currency_ = index->currency().code();
     }
-    LOG("LgmCalibration for qualifier " << qualifier << " (ccy=" << currency_ << "), configuration is " << configuration_);
+    LOG("LgmCalibration for qualifier " << qualifier << " (ccy=" << currency_ << "), configuration is "
+                                        << configuration_);
     Currency ccy = parseCurrency(currency_);
 
     requiresCalibration_ =
         (data_->calibrateA() || data_->calibrateH()) && data_->calibrationType() != CalibrationType::None;
 
-    // the discount curve underlying the model might be relinked to a different curve outside this builder
-    // the calibration curve should always stay the same though, therefore we create a different handle for this
-    modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*market_->discountCurve(currency_, configuration_));
-    calibrationDiscountCurve_ = Handle<YieldTermStructure>(*modelDiscountCurve_);
+    swapIndex_ = market_->swapIndex(market_->swapIndexBase(data_->qualifier(), configuration_), configuration_);
+    // see the comment for dinscountCurve() in the interface
+    modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
 
     if (requiresCalibration_) {
         svts_ = market_->swaptionVol(data_->qualifier(), configuration_);
-        swapIndex_ = market_->swapIndex(market_->swapIndexBase(data_->qualifier(), configuration_), configuration_);
-        shortSwapIndex_ = market_->swapIndex(market_->shortSwapIndexBase(data_->qualifier(), configuration_), configuration_);
+        shortSwapIndex_ =
+            market_->swapIndex(market_->shortSwapIndexBase(data_->qualifier(), configuration_), configuration_);
         registerWith(svts_);
         marketObserver_->addObservable(swapIndex_->forwardingTermStructure());
-        marketObserver_->addObservable(swapIndex_->discountingTermStructure());
         marketObserver_->addObservable(shortSwapIndex_->forwardingTermStructure());
         marketObserver_->addObservable(shortSwapIndex_->discountingTermStructure());
     }
-    marketObserver_->addObservable(calibrationDiscountCurve_);
+    marketObserver_->addObservable(swapIndex_->discountingTermStructure());
     registerWith(marketObserver_);
     // notify observers of all market data changes, not only when not calculated
     alwaysForwardNotifications();
@@ -321,7 +320,7 @@ void LgmBuilder::performCalculations() const {
     // reset lgm observer's updated flag
     marketObserver_->hasUpdated(true);
 
-    if (swaptionBasketRefDate_ != calibrationDiscountCurve_->referenceDate()) {
+    if (swaptionBasketRefDate_ != swapIndex_->discountingTermStructure()->referenceDate()) {
         // build swaption basket if required, i.e. if reference date has changed since last build
         buildSwaptionBasket();
         volSurfaceChanged(true);
@@ -333,7 +332,8 @@ void LgmBuilder::performCalculations() const {
     }
 
     for (Size j = 0; j < swaptionBasket_.size(); j++) {
-        auto engine = boost::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, calibrationDiscountCurve_);
+        auto engine =
+            boost::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, swapIndex_->discountingTermStructure());
         engine->enableCache(!data_->calibrateH(), !data_->calibrateA());
         swaptionBasket_[j]->setPricingEngine(engine);
         // necessary if notifications are disabled (observation mode = Disable)
@@ -387,15 +387,15 @@ void LgmBuilder::performCalculations() const {
         if (Log::instance().filter(ORE_DATA) || setCalibrationInfo_) {
             TLOGGERSTREAM("Basket details:");
             try {
-		auto d = getBasketDetails(calibrationInfo);
+                auto d = getBasketDetails(calibrationInfo);
                 TLOGGERSTREAM(d);
             } catch (const std::exception& e) {
                 WLOG("An error occurred: " << e.what());
             }
             TLOGGERSTREAM("Calibration details (with time grid = calibration swaption expiries):");
             try {
-		auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
-		TLOGGERSTREAM(d);
+                auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
+                TLOGGERSTREAM(d);
             } catch (const std::exception& e) {
                 WLOG("An error occurred: " << e.what());
             }
@@ -410,14 +410,14 @@ void LgmBuilder::performCalculations() const {
         StructuredModelErrorMessage(errorTemplate, exceptionMessage, id_).log();
         WLOGGERSTREAM("Basket details:");
         try {
-	    auto d = getBasketDetails(calibrationInfo);
+            auto d = getBasketDetails(calibrationInfo);
             WLOGGERSTREAM(d);
         } catch (const std::exception& e) {
             WLOG("An error occurred: " << e.what());
         }
         WLOGGERSTREAM("Calibration details (with time grid = calibration swaption expiries):");
         try {
-	    auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
+            auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
             WLOGGERSTREAM(d);
         } catch (const std::exception& e) {
             WLOG("An error occurred: " << e.what());
@@ -548,8 +548,6 @@ void LgmBuilder::buildSwaptionBasket() const {
 
     std::ostringstream log;
 
-    Handle<YieldTermStructure> yts = market_->discountCurve(currency_, configuration_);
-
     std::vector<Time> expiryTimes;
     std::vector<Time> maturityTimes;
     swaptionBasket_.clear();
@@ -586,7 +584,7 @@ void LgmBuilder::buildSwaptionBasket() const {
         RateAveraging::Type averagingMethod = RateAveraging::Compound;
         if (auto on = dynamic_pointer_cast<OvernightIndexedSwapIndex>(*swapIndex_)) {
             settlementDays = on->fixingDays();
-	    averagingMethod = on->averagingMethod();
+            averagingMethod = on->averagingMethod();
         }
 
         Real dummyQuote = svts_->volatilityType() == Normal ? 0.0020 : 0.10;
@@ -597,28 +595,32 @@ void LgmBuilder::buildSwaptionBasket() const {
 
         if (expiryDateBased && termDateBased) {
             Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryDb, termT) : 0.0;
-            std::tie(helper, updatedStrike) = createSwaptionHelper(
-                expiryDb, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter, yts,
-                calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) =
+                createSwaptionHelper(expiryDb, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter,
+                                     floatDayCounter, swapIndex_->discountingTermStructure(), calibrationErrorType_,
+                                     strikeValue, shift, settlementDays, averagingMethod);
         }
         if (expiryDateBased && !termDateBased) {
             Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryDb, termPb) : 0.0;
-            std::tie(helper, updatedStrike) = createSwaptionHelper(
-                expiryDb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter, yts,
-                calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) =
+                createSwaptionHelper(expiryDb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter,
+                                     floatDayCounter, swapIndex_->discountingTermStructure(), calibrationErrorType_,
+                                     strikeValue, shift, settlementDays, averagingMethod);
         }
         if (!expiryDateBased && termDateBased) {
             Date expiry = svts_->optionDateFromTenor(expiryPb);
             Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryPb, termT) : 0.0;
-            std::tie(helper, updatedStrike) = createSwaptionHelper(
-                expiry, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter, yts,
-                calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) =
+                createSwaptionHelper(expiry, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter,
+                                     floatDayCounter, swapIndex_->discountingTermStructure(), calibrationErrorType_,
+                                     strikeValue, shift, settlementDays, averagingMethod);
         }
         if (!expiryDateBased && !termDateBased) {
             Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryPb, termPb) : 0.0;
-            std::tie(helper, updatedStrike) = createSwaptionHelper(
-                expiryPb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter, yts,
-                calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) =
+                createSwaptionHelper(expiryPb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter,
+                                     floatDayCounter, swapIndex_->discountingTermStructure(), calibrationErrorType_,
+                                     strikeValue, shift, settlementDays, averagingMethod);
         }
 
         // check if we want to keep the helper when a reference calibration grid is given
@@ -630,10 +632,10 @@ void LgmBuilder::buildSwaptionBasket() const {
             swaptionBasketVols_.push_back(volQuote);
             swaptionBasket_.push_back(helper);
             swaptionStrike_.push_back(updatedStrike);
-            expiryTimes.push_back(yts->timeFromReference(expiryDate));
+            expiryTimes.push_back(swapIndex_->discountingTermStructure()->timeFromReference(expiryDate));
             Date matDate = helper->underlyingSwap() ? helper->underlyingSwap()->maturityDate()
                                                     : helper->underlyingOvernightIndexedSwap()->maturityDate();
-            maturityTimes.push_back(yts->timeFromReference(matDate));
+            maturityTimes.push_back(swapIndex_->discountingTermStructure()->timeFromReference(matDate));
             if (refCalDate != referenceCalibrationDates.end())
                 lastRefCalDate = *refCalDate;
         }
@@ -655,19 +657,18 @@ void LgmBuilder::buildSwaptionBasket() const {
     for (Size j = 0; j < maturityTimes.size(); j++)
         swaptionMaturities_[j] = maturityTimes[j];
 
-    swaptionBasketRefDate_ = calibrationDiscountCurve_->referenceDate();
+    swaptionBasketRefDate_ = swapIndex_->discountingTermStructure()->referenceDate();
 }
 
 std::string LgmBuilder::getBasketDetails(LgmCalibrationInfo& info) const {
     std::ostringstream log;
-    Handle<YieldTermStructure> yts = market_->discountCurve(currency_, configuration_);
     log << std::right << std::setw(3) << "#" << std::setw(16) << "expiry" << std::setw(16) << "swapLength"
         << std::setw(16) << "strike" << std::setw(16) << "atmForward" << std::setw(16) << "annuity" << std::setw(16)
         << "vega" << std::setw(16) << "vol\n";
     info.swaptionData.clear();
     for (Size j = 0; j < swaptionBasket_.size(); ++j) {
         auto swp = boost::static_pointer_cast<SwaptionHelper>(swaptionBasket_[j])->swaption();
-        auto sd = swaptionData(swp, yts, svts_);
+        auto sd = swaptionData(swp, swapIndex_->discountingTermStructure(), svts_);
         log << std::right << std::setw(3) << j << std::setw(16) << sd.timeToExpiry << std::setw(16) << sd.swapLength
             << std::setw(16) << sd.strike << std::setw(16) << sd.atmForward << std::setw(16) << sd.annuity
             << std::setw(16) << sd.vega << std::setw(16) << std::setw(16) << sd.stdDev / std::sqrt(sd.timeToExpiry)

OREData/ored/model/lgmbuilder.hpp

@@ -47,9 +47,9 @@ using namespace QuantLib;
  */
 class LgmBuilder : public QuantExt::ModelBuilder {
 public:
-    /*! The configuration should refer to the calibration configuration here,
-      alternative discounting curves are then usually set in the pricing
-      engines for swaptions etc. */
+    /*! The configuration refers to the configuration to read swaption vol and swap index from the market.
+        The discounting curve to price calibrating swaptions is derived from the swap index directly though,
+        i.e. it is not read as a discount curve from the market. */
     LgmBuilder(const boost::shared_ptr<ore::data::Market>& market, const boost::shared_ptr<IrLgmData>& data,
                const std::string& configuration = Market::defaultConfiguration, Real bootstrapTolerance = 0.001,
                const bool continueOnError = false, const std::string& referenceCalibrationGrid = "",
@@ -62,8 +62,11 @@ class LgmBuilder : public QuantExt::ModelBuilder {
     std::string qualifier() { return data_->qualifier(); }
     std::string ccy() { return currency_; }
     boost::shared_ptr<QuantExt::LGM> model() const;
-    boost::shared_ptr<QuantExt::IrLgm1fParametrization> parametrization() const;
+    /* the curve used to build the lgm parametrization, this can be relinked later outside this builder to e.g.
+       calibrate fx processes using an xccy curve instead of the in currency curve that we use for the calibration of
+       the LGM model in this builder */
     RelinkableHandle<YieldTermStructure> discountCurve() { return modelDiscountCurve_; }
+    boost::shared_ptr<QuantExt::IrLgm1fParametrization> parametrization() const;
     std::vector<boost::shared_ptr<BlackCalibrationHelper>> swaptionBasket() const;
     //@}
 
@@ -111,10 +114,9 @@ class LgmBuilder : public QuantExt::ModelBuilder {
     mutable Array swaptionMaturities_;
     mutable Date swaptionBasketRefDate_;
 
-    RelinkableHandle<YieldTermStructure> modelDiscountCurve_;
-    Handle<YieldTermStructure> calibrationDiscountCurve_;
     Handle<QuantLib::SwaptionVolatilityStructure> svts_;
     Handle<SwapIndex> swapIndex_, shortSwapIndex_;
+    RelinkableHandle<YieldTermStructure> modelDiscountCurve_;
 
     // TODO: Move CalibrationErrorType, optimizer and end criteria parameters to data
     boost::shared_ptr<OptimizationMethod> optimizationMethod_;