Resolve QPR-11618 american swaption pt 2 / 2

Author: rolandlichters

Docs/UserGuide/tradedata/swaption.tex

@@ -6,7 +6,7 @@ \subsubsection{Swaption}
 component sub-node.  These trade components are outlined in section \ref{ss:option_data} and section
 \ref{ss:leg_data}.\\
 \vspace{5mm}
-Supported swaption exercise styles are \emph{European} and \emph{Bermudan}. Swaptions of both exercise styles can have an arbitrary number of legs, with
+Supported swaption exercise styles are \emph{European}, \emph{Bermudan}, \emph{American}. Swaptions of all exercise styles can have an arbitrary number of legs, with
 each leg represented by a \lstinline!LegData! sub-node.  Cross currency swaptions are not supported for either exercise style, i.e. the Currency element must
 have the same value for all \lstinline!LegData! sub-nodes of a swaption. There must be at least one full coupon period after the exercise date for European 
 Swaptions, and after the last exercise date for Bermudan Swaptions. See Table \ref{tab:swaption_requirements} for further details on requirements for

Examples/Example_15/ExpectedOutput/npv.csv

@@ -1,5 +1,5 @@
 #TradeId,TradeType,Maturity,MaturityTime,NPV,NpvCurrency,NPV(Base),BaseCurrency,Notional,NotionalCurrency,Notional(Base),NettingSet,CounterParty
-BERMUDAN_SWAPTION,Swaption,2038-10-01,22.652317,-3115851.065563,EUR,-3115851.065563,EUR,10000000.00,EUR,10000000.00,CPTY_A,CPTY_A
+BERMUDAN_SWAPTION,Swaption,2038-10-01,22.652317,-3115844.394193,EUR,-3115844.394193,EUR,10000000.00,EUR,10000000.00,CPTY_A,CPTY_A
 BOND,Bond,2021-02-03,4.994783,12902649.282760,EUR,12902649.282760,EUR,10000000.00,EUR,10000000.00,CPTY_A,CPTY_A
 Bond_Floating,Bond,2021-02-03,4.994783,10765048.489931,EUR,10765048.489931,EUR,10000000.00,EUR,10000000.00,,CPTY_C
 CAP_EUR,CapFloor,2026-02-09,10.011221,-6881.951398,EUR,-6881.951398,EUR,1000000.00,EUR,1000000.00,CPTY_A,CPTY_A

Examples/Example_15/ExpectedOutput/scenario.csv

@@ -1,6 +1,6 @@
 #TradeId,ScenarioLabel,Base NPV,Scenario NPV,Sensitivity
-BERMUDAN_SWAPTION,parallel_rates,-3100941.24,-2043549.12,1057392.12
-BERMUDAN_SWAPTION,twist,-3100941.24,-3165028.92,-64087.68
+BERMUDAN_SWAPTION,parallel_rates,-3100934.56,-2043542.97,1057391.59
+BERMUDAN_SWAPTION,twist,-3100934.56,-3165020.59,-64086.03
 BOND,parallel_rates,12902111.76,12614454.85,-287656.90
 BOND,twist,12902111.76,12801562.04,-100549.71
 Bond_Floating,parallel_rates,10765631.07,10511973.88,-253657.19

Examples/Example_15/ExpectedOutput/sensitivity.csv

@@ -1,20 +1,20 @@
 #Portfolio,RiskClass,RiskType,Quantile_0.010000,Quantile_0.050000,Quantile_0.950000,Quantile_0.990000
-(all),(all),(all),-51235590.702637,-36273022.490219,35954247.490219,50916815.702637
+(all),(all),(all),-51235588.420345,-36273020.290624,35954249.290624,50916817.420345
 PF1,(all),(all),-50726701.680738,-35873450.367032,35826125.367032,50679376.680738
-PF2,(all),(all),-6496762.740931,-4633322.329692,4361872.329692,6225312.740931
-(all),(all),DeltaGamma,-51228597.857258,-36266113.235621,35960753.235621,50923237.857258
+PF2,(all),(all),-6496758.482691,-4633318.732994,4361872.732994,6225312.482691
+(all),(all),DeltaGamma,-51228597.579535,-36266113.039256,35960753.039256,50923237.579535
 PF1,(all),DeltaGamma,-50726701.680738,-35873450.367032,35826125.367032,50679376.680738
-PF2,(all),DeltaGamma,-6487763.642587,-4624994.545862,4366959.545862,6229728.642587
-(all),(all),Vega,-177437.215274,-127422.632151,114007.632151,164022.215274
-PF2,(all),Vega,-177437.215274,-127422.632151,114007.632151,164022.215274
-(all),InterestRate,(all),-36990503.836512,-26202194.865752,25875101.865752,36663410.836512
+PF2,(all),DeltaGamma,-6487761.420238,-4624992.974542,4366957.974542,6229726.420238
+(all),(all),Vega,-177433.848212,-127419.665564,114008.665564,164022.848212
+PF2,(all),Vega,-177433.848212,-127419.665564,114008.665564,164022.848212
+(all),InterestRate,(all),-36990501.444995,-26202192.588929,25875103.588929,36663412.444995
 PF1,InterestRate,(all),-36286970.228997,-25662864.686621,25621789.686621,36245895.228997
-PF2,InterestRate,(all),-6495322.849454,-4634438.067121,4348420.067121,6209304.849454
-(all),InterestRate,DeltaGamma,-36983211.482402,-26195003.828212,25881803.828212,36670011.482402
+PF2,InterestRate,(all),-6495318.588113,-4634434.468231,4348420.468231,6209304.588113
+(all),InterestRate,DeltaGamma,-36983211.097219,-26195003.555867,25881803.555867,36670011.097219
 PF1,InterestRate,DeltaGamma,-36286970.228997,-25662864.686621,25621789.686621,36245895.228997
-PF2,InterestRate,DeltaGamma,-6486370.984829,-4626073.665994,4353948.665994,6214245.984829
-(all),InterestRate,Vega,-166550.351677,-119795.045528,105902.045528,152657.351677
-PF2,InterestRate,Vega,-166550.351677,-119795.045528,105902.045528,152657.351677
+PF2,InterestRate,DeltaGamma,-6486368.759528,-4626072.092586,4353947.092586,6214243.759528
+(all),InterestRate,Vega,-166546.889318,-119792.011561,105903.011561,152657.889318
+PF2,InterestRate,Vega,-166546.889318,-119792.011561,105903.011561,152657.889318
 (all),Inflation,(all),-304149.096627,-215013.224331,215263.224331,304399.096627
 PF1,Inflation,(all),-304149.096627,-215013.224331,215263.224331,304399.096627
 (all),Inflation,DeltaGamma,-304149.096627,-215013.224331,215263.224331,304399.096627

Examples/Example_15/ExpectedOutput/stresstest.csv

@@ -64,6 +64,29 @@
       <Parameter name="nx">10</Parameter>
     </EngineParameters>
   </Product>
+  <Product type="AmericanSwaption">
+    <Model>LGM</Model>
+    <ModelParameters>
+      <Parameter name="Calibration">Bootstrap</Parameter>
+      <Parameter name="CalibrationStrategy">CoterminalATM</Parameter>
+      <Parameter name="Reversion">0.03</Parameter>
+      <Parameter name="ReversionType">HullWhite</Parameter>
+      <Parameter name="Volatility">0.01</Parameter>
+      <Parameter name="VolatilityType">Hagan</Parameter>
+      <!-- shift horizon as ratio of maturity time -->
+      <Parameter name="ShiftHorizon">0.5</Parameter>
+      <Parameter name="Tolerance">0.0001</Parameter>
+      <Parameter name="ReferenceCalibrationGrid">400,3M</Parameter>
+      <Parameter name="ExerciseTimeStepsPerYear">24</Parameter>
+    </ModelParameters>
+     <Engine>FD</Engine>
+    <EngineParameters>
+      <Parameter name="Scheme">Douglas</Parameter>
+      <Parameter name="StateGridPoints">64</Parameter>
+      <Parameter name="TimeStepsPerYear">24</Parameter>
+      <Parameter name="MesherEpsilon">1E-4</Parameter>
+    </EngineParameters>
+ </Product>
   <Product type="CapFloor">
     <Model>IborCapModel</Model>
     <ModelParameters/>

Examples/Example_15/ExpectedOutput/var.csv

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2016-2022 Quaternion Risk Management Ltd
+ Copyright (C) 2016 Quaternion Risk Management Ltd
  All rights reserved.
 
  This file is part of ORE, a free-software/open-source library
@@ -18,16 +18,16 @@
 
 #include <ored/model/lgmbuilder.hpp>
 #include <ored/portfolio/builders/swaption.hpp>
+#include <ored/utilities/dategrid.hpp>
 #include <ored/utilities/parsers.hpp>
 #include <ored/utilities/to_string.hpp>
 
 #include <ql/methods/montecarlo/lsmbasissystem.hpp>
 #include <ql/pricingengines/swaption/blackswaptionengine.hpp>
-#include <ql/pricingengines/swaption/blackswaptionengine.hpp>
 
 #include <qle/methods/multipathgeneratorbase.hpp>
-#include <qle/pricingengines/numericlgmmultilegoptionengine.hpp>
 #include <qle/pricingengines/mcmultilegoptionengine.hpp>
+#include <qle/pricingengines/numericlgmmultilegoptionengine.hpp>
 
 #include <set>
 
@@ -77,17 +77,19 @@ boost::shared_ptr<PricingEngine> EuropeanSwaptionEngineBuilder::engineImpl(const
     }
 }
 
-boost::shared_ptr<QuantExt::LGM> LGMBermudanSwaptionEngineBuilder::model(const string& id, const string& key,
-                                                                         const std::vector<Date>& expiries,
-                                                                         const Date& maturity,
-                                                                         const std::vector<Real>& strikes) {
+boost::shared_ptr<QuantExt::LGM> LGMBermudanAmericanSwaptionEngineBuilder::model(const string& id, const string& key,
+                                                                                 const std::vector<Date>& expiries,
+                                                                                 const Date& maturity,
+                                                                                 const std::vector<Real>& strikes,
+                                                                                 const bool isAmerican) {
     boost::shared_ptr<IborIndex> index;
     std::string ccy = tryParseIborIndex(key, index) ? index->currency().code() : key;
 
     DLOG("Get model data");
     auto calibration = parseCalibrationType(modelParameter("Calibration"));
     auto calibrationStrategy = parseCalibrationStrategy(modelParameter("CalibrationStrategy"));
-    std::string referenceCalibrationGrid = modelParameter("ReferenceCalibrationGrid", {}, false, "");
+    // required for american options to set up calibration basket
+    std::string referenceCalibrationGrid = modelParameter("ReferenceCalibrationGrid", {}, isAmerican, "");
     Real lambda = parseReal(modelParameter("Reversion", {key, ccy}));
     vector<Real> sigma = parseListOfValues<Real>(modelParameter("Volatility"), &parseReal);
     vector<Real> sigmaTimes = parseListOfValues<Real>(modelParameter("VolatilityTimes", {}, false), &parseReal);
@@ -135,21 +137,45 @@ boost::shared_ptr<QuantExt::LGM> LGMBermudanSwaptionEngineBuilder::model(const s
     data->calibrationType() = calibration;
     data->shiftHorizon() = shiftHorizon;
 
+    std::vector<Date> effExpiries;
+    std::vector<Real> effStrikes;
+    if (!isAmerican) {
+        effExpiries = expiries;
+        effStrikes = strikes;
+    } else {
+        QL_REQUIRE(expiries.size() == 2 && strikes.size() == 2,
+                   "LGMBermudanAmericanSwaptionEngineBuilder::model(): expected 2 expiries and strikes for exercise "
+                   "style 'American', got "
+                       << expiries.size() << " expiries and " << strikes.size() << " strikes.");
+        // keep one calibration instrument per reference grid interval
+        DateGrid grid(referenceCalibrationGrid);
+        std::copy_if(grid.dates().begin(), grid.dates().end(), std::back_inserter(effExpiries),
+                     [&expiries](const Date& d) { return d >= expiries[0] && d < expiries[1]; });
+        // simple linear interpolation of calibration strikes between endpoints, this can be refined obviously
+        effStrikes.resize(effExpiries.size());
+        Real t0 = Actual365Fixed().yearFraction(today, expiries[0]);
+        Real t1 = Actual365Fixed().yearFraction(today, expiries[1]);
+        for(Size i=0;i<effExpiries.size();++i) {
+            Real t = Actual365Fixed().yearFraction(today, effExpiries[i]);
+            effStrikes[i] = strikes[0] + (strikes[1] - strikes[0]) / (t1 - t0) * (t - t0);
+        }
+    }
+
     if (calibrationStrategy == CalibrationStrategy::CoterminalATM ||
         calibrationStrategy == CalibrationStrategy::CoterminalDealStrike) {
         DLOG("Build LgmData for co-terminal specification");
         vector<string> expiryDates, termDates;
-        for (Size i = 0; i < expiries.size(); ++i) {
-            expiryDates.push_back(to_string(expiries[i]));
+        for (Size i = 0; i < effExpiries.size(); ++i) {
+            expiryDates.push_back(to_string(effExpiries[i]));
             termDates.push_back(to_string(maturity));
         }
         data->optionExpiries() = expiryDates;
         data->optionTerms() = termDates;
         data->optionStrikes().resize(expiryDates.size(), "ATM");
         if (calibrationStrategy == CalibrationStrategy::CoterminalDealStrike) {
-            for (Size i = 0; i < expiries.size(); ++i) {
-                if (strikes[i] != Null<Real>())
-                    data->optionStrikes()[i] = std::to_string(strikes[i]);
+            for (Size i = 0; i < effExpiries.size(); ++i) {
+                if (effStrikes[i] != Null<Real>())
+                    data->optionStrikes()[i] = std::to_string(effStrikes[i]);
             }
         }
         if (calibration == CalibrationType::Bootstrap) {
@@ -202,13 +228,13 @@ boost::shared_ptr<QuantExt::LGM> LGMBermudanSwaptionEngineBuilder::model(const s
     return model;
 }
 
-boost::shared_ptr<PricingEngine> LGMGridBermudanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
-                                                                                  const std::vector<Date>& expiries,
-                                                                                  const Date& maturity,
-                                                                                  const std::vector<Real>& strikes) {
-    DLOG("Building LGM Grid Bermudan Swaption engine for trade " << id);
+boost::shared_ptr<PricingEngine>
+LGMGridBermudanAmericanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
+                                                         const std::vector<Date>& expiries, const Date& maturity,
+                                                         const std::vector<Real>& strikes, const bool isAmerican) {
+    DLOG("Building LGM Grid Bermudan/American Swaption engine for trade " << id);
 
-    boost::shared_ptr<QuantExt::LGM> lgm = model(id, key, expiries, maturity, strikes);
+    boost::shared_ptr<QuantExt::LGM> lgm = model(id, key, expiries, maturity, strikes, isAmerican);
 
     DLOG("Get engine data");
     Real sy = parseReal(engineParameter("sy"));
@@ -221,16 +247,17 @@ boost::shared_ptr<PricingEngine> LGMGridBermudanSwaptionEngineBuilder::engineImp
     boost::shared_ptr<IborIndex> index;
     std::string ccy = tryParseIborIndex(key, index) ? index->currency().code() : key;
     return boost::make_shared<QuantExt::NumericLgmMultiLegOptionEngine>(
-        lgm, sy, ny, sx, nx, market_->discountCurve(ccy, configuration(MarketContext::pricing)));
+        lgm, sy, ny, sx, nx, market_->discountCurve(ccy, configuration(MarketContext::pricing)),
+        isAmerican ? parseInteger(modelParameter("ExerciseTimeStepsPerYear")) : 0);
 }
 
-boost::shared_ptr<PricingEngine> LGMFDBermudanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
-                                                                                const std::vector<Date>& expiries,
-                                                                                const Date& maturity,
-                                                                                const std::vector<Real>& strikes) {
-    DLOG("Building LGM FD Bermudan Swaption engine for trade " << id);
+boost::shared_ptr<PricingEngine>
+LGMFDBermudanAmericanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
+                                                       const std::vector<Date>& expiries, const Date& maturity,
+                                                       const std::vector<Real>& strikes, const bool isAmerican) {
+    DLOG("Building LGM FD Bermudan/American Swaption engine for trade " << id);
 
-    boost::shared_ptr<QuantExt::LGM> lgm = model(id, key, expiries, maturity, strikes);
+    boost::shared_ptr<QuantExt::LGM> lgm = model(id, key, expiries, maturity, strikes, isAmerican);
 
     DLOG("Get engine data");
     QuantLib::FdmSchemeDesc scheme = parseFdmSchemeDesc(engineParameter("Scheme"));
@@ -245,16 +272,17 @@ boost::shared_ptr<PricingEngine> LGMFDBermudanSwaptionEngineBuilder::engineImpl(
     std::string ccy = tryParseIborIndex(key, index) ? index->currency().code() : key;
     return boost::make_shared<QuantExt::NumericLgmMultiLegOptionEngine>(
         lgm, maxTime, scheme, stateGridPoints, timeStepsPerYear, mesherEpsilon,
-        market_->discountCurve(ccy, configuration(MarketContext::pricing)));
+        market_->discountCurve(ccy, configuration(MarketContext::pricing)),
+        isAmerican ? parseInteger(modelParameter("ExerciseTimeStepsPerYear")) : 0);
 }
 
-boost::shared_ptr<PricingEngine> LgmMcBermudanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
-                                                                                const std::vector<Date>& expiries,
-                                                                                const Date& maturity,
-                                                                                const std::vector<Real>& strikes) {
-    DLOG("Building MC Bermudan Swaption engine for trade " << id);
+boost::shared_ptr<PricingEngine>
+LgmMcBermudanAmericanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
+                                                       const std::vector<Date>& expiries, const Date& maturity,
+                                                       const std::vector<Real>& strikes, const bool isAmerican) {
+    DLOG("Building MC Bermudan/American Swaption engine for trade " << id);
 
-    auto lgm = model(id, key, expiries, maturity, strikes);
+    auto lgm = model(id, key, expiries, maturity, strikes, isAmerican);
 
     // Build engine
     DLOG("Build engine (configuration " << configuration(MarketContext::pricing) << ")");
@@ -265,16 +293,17 @@ boost::shared_ptr<PricingEngine> LgmMcBermudanSwaptionEngineBuilder::engineImpl(
                          std::vector<Date>(), std::vector<Size>());
 } // LgmMc engineImpl()
 
-boost::shared_ptr<PricingEngine> LgmAmcBermudanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
-                                                                                 const std::vector<Date>& expiries,
-                                                                                 const Date& maturity,
-                                                                                 const std::vector<Real>& strikes) {
+boost::shared_ptr<PricingEngine>
+LgmAmcBermudanAmericanSwaptionEngineBuilder::engineImpl(const string& id, const string& key,
+                                                        const std::vector<Date>& expiries, const Date& maturity,
+                                                        const std::vector<Real>& strikes, const bool isAmerican) {
     boost::shared_ptr<IborIndex> index;
     std::string ccy = tryParseIborIndex(key, index) ? index->currency().code() : key;
     Currency curr = parseCurrency(ccy);
-    DLOG("Building AMC Bermudan Swaption engine for key " << key << ", ccy " << ccy << " (from externally given CAM)");
+    DLOG("Building AMC Bermudan/American Swaption engine for key " << key << ", ccy " << ccy
+                                                                   << " (from externally given CAM)");
 
-    QL_REQUIRE(cam_ != nullptr, "LgmCamBermudanSwaptionEngineBuilder::engineImpl: cam is null");
+    QL_REQUIRE(cam_ != nullptr, "LgmCamBermudanAmericanSwaptionEngineBuilder::engineImpl: cam is null");
     Size currIdx = cam_->ccyIndex(curr);
     auto lgm = cam_->lgm(currIdx);
     std::vector<Size> modelIndex(1, cam_->pIdx(CrossAssetModel::AssetType::IR, currIdx));