QPR-12306 store calibration discount curve separately from model discount curve

the cam model builder relinks the model discount curve, so on recalibration of the lgm component a wrong discount curve
is used if we don't separate the calibration discount curve from the model discount curve

Author: pcaspers

OREData/ored/model/lgmbuilder.cpp

@@ -196,13 +196,15 @@ LgmBuilder::LgmBuilder(const boost::shared_ptr<ore::data::Market>& market, const
         swapIndex_ = market_->swapIndex(market_->swapIndexBase(data_->qualifier(), configuration_), configuration_);
         // see the comment for dinscountCurve() in the interface
         modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
+        calibrationDiscountCurve_ = Handle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
     } catch (const std::exception& e) {
         StructuredModelErrorMessage(
             "Error when retrieving swap index base for qualifier '" + data_->qualifier() +
                 "'. Use market discount curve instead of swap index discount curve as a fallback.",
             e.what(), id_)
             .log();
         modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*market_->discountCurve(currency_, configuration_));
+        calibrationDiscountCurve_ = Handle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
     }
 
     if (requiresCalibration_) {
@@ -212,6 +214,7 @@ LgmBuilder::LgmBuilder(const boost::shared_ptr<ore::data::Market>& market, const
         marketObserver_->addObservable(shortSwapIndex_->discountingTermStructure());
     }
     marketObserver_->addObservable(modelDiscountCurve_);
+    marketObserver_->addObservable(calibrationDiscountCurve_);
     registerWith(marketObserver_);
     // notify observers of all market data changes, not only when not calculated
     alwaysForwardNotifications();
@@ -322,16 +325,18 @@ bool LgmBuilder::requiresRecalibration() const {
 void LgmBuilder::performCalculations() const {
 
     DLOG("Recalibrate LGM model for qualifier " << data_->qualifier() << " currency " << currency_);
+    std::cout << "reaclibrate model ... " << std::flush;
 
     if (!requiresRecalibration()) {
         DLOG("Skipping calibration as nothing has changed");
+        std::cout << " skipped." << std::endl;
         return;
     }
 
     // reset lgm observer's updated flag
     marketObserver_->hasUpdated(true);
 
-    if (swaptionBasketRefDate_ != modelDiscountCurve_->referenceDate()) {
+    if (swaptionBasketRefDate_ != calibrationDiscountCurve_->referenceDate()) {
         // build swaption basket if required, i.e. if reference date has changed since last build
         buildSwaptionBasket();
         volSurfaceChanged(true);
@@ -343,8 +348,7 @@ void LgmBuilder::performCalculations() const {
     }
 
     for (Size j = 0; j < swaptionBasket_.size(); j++) {
-        auto engine =
-            boost::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, modelDiscountCurve_);
+        auto engine = boost::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, calibrationDiscountCurve_);
         engine->enableCache(!data_->calibrateH(), !data_->calibrateA());
         swaptionBasket_[j]->setPricingEngine(engine);
         // necessary if notifications are disabled (observation mode = Disable)
@@ -459,6 +463,9 @@ void LgmBuilder::performCalculations() const {
         DLOG("Apply scaling " << data_->scaling() << " to the " << data_->qualifier() << " LGM model");
         parametrization_->scaling() = data_->scaling();
     }
+
+    std::cout << "  done." << std::endl;
+
 } // performCalculations()
 
 void LgmBuilder::getExpiryAndTerm(const Size j, Period& expiryPb, Period& termPb, Date& expiryDb, Date& termDb,
@@ -607,32 +614,28 @@ 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, modelDiscountCurve_, calibrationErrorType_,
-                                     strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) = createSwaptionHelper(
+                expiryDb, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
+                calibrationDiscountCurve_, 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, modelDiscountCurve_, calibrationErrorType_,
-                                     strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) = createSwaptionHelper(
+                expiryDb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
+                calibrationDiscountCurve_, 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, modelDiscountCurve_, calibrationErrorType_,
-                                     strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) = createSwaptionHelper(
+                expiry, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
+                calibrationDiscountCurve_, 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, modelDiscountCurve_, calibrationErrorType_,
-                                     strikeValue, shift, settlementDays, averagingMethod);
+            std::tie(helper, updatedStrike) = createSwaptionHelper(
+                expiryPb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
+                calibrationDiscountCurve_, calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
         }
 
         // check if we want to keep the helper when a reference calibration grid is given
@@ -644,10 +647,10 @@ void LgmBuilder::buildSwaptionBasket() const {
             swaptionBasketVols_.push_back(volQuote);
             swaptionBasket_.push_back(helper);
             swaptionStrike_.push_back(updatedStrike);
-            expiryTimes.push_back(modelDiscountCurve_->timeFromReference(expiryDate));
+            expiryTimes.push_back(calibrationDiscountCurve_->timeFromReference(expiryDate));
             Date matDate = helper->underlyingSwap() ? helper->underlyingSwap()->maturityDate()
                                                     : helper->underlyingOvernightIndexedSwap()->maturityDate();
-            maturityTimes.push_back(modelDiscountCurve_->timeFromReference(matDate));
+            maturityTimes.push_back(calibrationDiscountCurve_->timeFromReference(matDate));
             if (refCalDate != referenceCalibrationDates.end())
                 lastRefCalDate = *refCalDate;
         }
@@ -669,7 +672,7 @@ void LgmBuilder::buildSwaptionBasket() const {
     for (Size j = 0; j < maturityTimes.size(); j++)
         swaptionMaturities_[j] = maturityTimes[j];
 
-    swaptionBasketRefDate_ = modelDiscountCurve_->referenceDate();
+    swaptionBasketRefDate_ = calibrationDiscountCurve_->referenceDate();
 }
 
 std::string LgmBuilder::getBasketDetails(LgmCalibrationInfo& info) const {
@@ -680,7 +683,7 @@ std::string LgmBuilder::getBasketDetails(LgmCalibrationInfo& info) const {
     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, modelDiscountCurve_, svts_);
+        auto sd = swaptionData(swp, calibrationDiscountCurve_, 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

@@ -117,6 +117,7 @@ class LgmBuilder : public QuantExt::ModelBuilder {
     Handle<QuantLib::SwaptionVolatilityStructure> svts_;
     Handle<SwapIndex> swapIndex_, shortSwapIndex_;
     RelinkableHandle<YieldTermStructure> modelDiscountCurve_;
+    Handle<YieldTermStructure> calibrationDiscountCurve_;
 
     // TODO: Move CalibrationErrorType, optimizer and end criteria parameters to data
     boost::shared_ptr<OptimizationMethod> optimizationMethod_;