git subrepo pull (merge) ore

subrepo:
  subdir:   "ore"
  merged:   "be37222c1e"
upstream:
  origin:   "git@gitlab.acadiasoft.net:qs/ore.git"
  branch:   "master"
  commit:   "989545210c"
git-subrepo:
  version:  "0.4.6"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "73a0129"

Author: jenkins

Docs/UserGuide/parameterisation/pricingengines.tex

@@ -355,6 +355,8 @@ \subsubsection{Product Type: EuropeanSwaption}
 \item VolatilityType: Hagan, HullWhite
 \item ShiftHorizon: Shift horizon for LGM model as fraction of deal maturity
 \item Tolerance: Error tolerance for calibration
+\item FloatSpreadMapping: mapping of float spreads in analytic swaption pricing for model calibration: proRata,
+  nextCoupon, simple, optional, defaults to proRata.
 \item sy, sx: Number of covered standard deviations (notation as in Hagan's paper)
 \item ny, nx: Number of grid points for numerical integration (notation as in Hagan's paper)
 \item SensitivityTemplate [optional]: the sensitivity template to use 
@@ -374,6 +376,7 @@ \subsubsection{Product Type: EuropeanSwaption}
         <Parameter name="VolatilityType">Hagan</Parameter>
         <Parameter name="ShiftHorizon">0.5</Parameter>
         <Parameter name="Tolerance">0.20</Parameter>
+        <Parameter name="FloatSpreadMapping">proRata</Parameter>
     </ModelParameters>
     <Engine>Grid</Engine>
     <EngineParameters>

Docs/UserGuide/userguide.tex

@@ -5204,6 +5204,7 @@ \subsubsection{Model}\label{sec:sim_model}
         <ShiftHorizon>0.0</ShiftHorizon>
         <Scaling>1.0</Scaling>
       </ParameterTransformation>
+      <FloatSpreadMapping>proRata</FloatSpreadMapping>
     </LGM>
     <LGM ccy="EUR">
       <!-- ... -->
@@ -5241,6 +5242,8 @@ \subsubsection{Model}\label{sec:sim_model}
 \item {\tt ParameterTransformation: } LGM model prices are invariant under scaling and shift transformations
 \cite{Lichters} with advantages for numerical convergence of results in long term simulations. These transformations can
 be chosen here. Default settings are shiftHorizon 0 (time in years) and scaling factor 1.
+\item {\tt FloatSpreadMapping: } mapping of float spreads in analytic swaption pricing for model calibration: proRata,
+  nextCoupon, simple, optional, defaults to proRata.
 \end{itemize}
 
 The reason for having to specify one more {\tt Volatility/InitialValue} entries than {\tt Volatility/TimeGrid} entries (and at least one more calibration option than {\tt Volatility/TimeGrid} entries) is the fact that the intervals defined by the {\tt Volatility/TimeGrid} entries are spanning from $[0,t_1],[t_1,t_2]\ldots[t_n,\infty]$, which results in $n+1$ intervals.

OREData/ored/model/lgmbuilder.cpp

@@ -346,7 +346,8 @@ void LgmBuilder::performCalculations() const {
     }
 
     for (Size j = 0; j < swaptionBasket_.size(); j++) {
-        auto engine = QuantLib::ext::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, calibrationDiscountCurve_);
+        auto engine = QuantLib::ext::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, calibrationDiscountCurve_,
+                                                                                      data_->floatSpreadMapping());
         engine->enableCache(!data_->calibrateH(), !data_->calibrateA());
         swaptionBasket_[j]->setPricingEngine(engine);
         // necessary if notifications are disabled (observation mode = Disable)

OREData/ored/model/lgmdata.cpp

@@ -97,6 +97,29 @@ std::ostream& operator<<(std::ostream& oss, const LgmData::VolatilityType& type)
     return oss;
 }
 
+QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping parseFloatSpreadMapping(const string& s) {
+    if (boost::algorithm::to_upper_copy(s) == "NEXTCOUPON")
+        return QuantExt::AnalyticLgmSwaptionEngine::nextCoupon;
+    else if (boost::algorithm::to_upper_copy(s) == "PRORATA")
+        return QuantExt::AnalyticLgmSwaptionEngine::proRata;
+    else if (boost::algorithm::to_upper_copy(s) == "SIMPLE")
+        return QuantExt::AnalyticLgmSwaptionEngine::simple;
+    else
+        QL_FAIL("FloatSpreadMapping '" << s << "' not recognized");
+}
+
+std::ostream& operator<<(std::ostream& oss, const QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping& m) {
+    if (m == QuantExt::AnalyticLgmSwaptionEngine::nextCoupon)
+        oss << "NEXTCOUPON";
+    else if (m == QuantExt::AnalyticLgmSwaptionEngine::proRata)
+        oss << "PRORATA";
+    else if (m == QuantExt::AnalyticLgmSwaptionEngine::simple)
+        oss << "SIMPLE";
+    else
+        QL_FAIL("FloatSpreadMapping type not covered");
+    return oss;
+}
+
 void LgmData::clear() {
     optionExpiries_.clear();
     optionTerms_.clear();
@@ -117,7 +140,6 @@ void LgmData::reset() {
     aValues_ = {0.01};
     shiftHorizon_ = 0.0;
     scaling_ = 1.0;
-    
 }
 
 void LgmData::fromXML(XMLNode* node) {
@@ -174,6 +196,9 @@ void LgmData::fromXML(XMLNode* node) {
         scaling_ = 1.0;
     }
 
+    floatSpreadMapping_ =
+        parseFloatSpreadMapping(XMLUtils::getChildValue(node, "FloatSpreadMapping", false, "proRata"));
+
     IrModelData::fromXML(node);
 
     LOG("LgmData done");
@@ -210,6 +235,8 @@ XMLNode* LgmData::toXML(XMLDocument& doc) const {
     XMLUtils::addChild(doc, parameterTransformationNode, "ShiftHorizon", shiftHorizon_);
     XMLUtils::addChild(doc, parameterTransformationNode, "Scaling", scaling_);
 
+    XMLUtils::addChild(doc, lgmNode, "FloatSpreadMapping", ore::data::to_string(floatSpreadMapping_));
+
     return lgmNode;
 }
 

OREData/ored/model/lgmdata.hpp

@@ -29,6 +29,7 @@
 #include <ql/types.hpp>
 
 #include <qle/models/lgm.hpp>
+#include <qle/pricingengines/analyticlgmswaptionengine.hpp>
 
 #include <ored/configuration/conventions.hpp>
 #include <ored/marketdata/market.hpp>
@@ -82,11 +83,13 @@ class LgmData : public IrModelData {
             ParamType aType, std::vector<Time> aTimes, std::vector<Real> aValues, Real shiftHorizon = 0.0,
             Real scaling = 1.0, std::vector<std::string> optionExpiries = std::vector<std::string>(),
             std::vector<std::string> optionTerms = std::vector<std::string>(),
-            std::vector<std::string> optionStrikes = std::vector<std::string>())
-        : IrModelData("LGM", qualifier, calibrationType), revType_(revType), volType_(volType),
-          calibrateH_(calibrateH), hType_(hType), hTimes_(hTimes), hValues_(hValues), calibrateA_(calibrateA),
-          aType_(aType), aTimes_(aTimes), aValues_(aValues), shiftHorizon_(shiftHorizon), scaling_(scaling),
-          optionExpiries_(optionExpiries), optionTerms_(optionTerms), optionStrikes_(optionStrikes) {}
+            std::vector<std::string> optionStrikes = std::vector<std::string>(),
+            const QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping inputFloatSpreadMapping =
+                QuantExt::AnalyticLgmSwaptionEngine::proRata)
+        : IrModelData("LGM", qualifier, calibrationType), revType_(revType), volType_(volType), calibrateH_(calibrateH),
+          hType_(hType), hTimes_(hTimes), hValues_(hValues), calibrateA_(calibrateA), aType_(aType), aTimes_(aTimes),
+          aValues_(aValues), shiftHorizon_(shiftHorizon), scaling_(scaling), optionExpiries_(optionExpiries),
+          optionTerms_(optionTerms), optionStrikes_(optionStrikes), floatSpreadMapping_(inputFloatSpreadMapping) {}
 
     //! Clear list of calibration instruments
     void clear() override;
@@ -114,6 +117,7 @@ class LgmData : public IrModelData {
     std::vector<Real>& aValues() { return aValues_; }
     Real& shiftHorizon() { return shiftHorizon_; }
     Real& scaling() { return scaling_; }
+    QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping& floatSpreadMapping() { return floatSpreadMapping_; }
     std::vector<std::string>& optionExpiries() const { return optionExpiries_; }
     std::vector<std::string>& optionTerms() const { return optionTerms_; }
     std::vector<std::string>& optionStrikes() const { return optionStrikes_; }
@@ -142,15 +146,19 @@ class LgmData : public IrModelData {
     mutable std::vector<std::string> optionExpiries_;
     mutable std::vector<std::string> optionTerms_;
     mutable std::vector<std::string> optionStrikes_;
+    QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping floatSpreadMapping_ =
+        QuantExt::AnalyticLgmSwaptionEngine::proRata;
 };
 
-//! Enum parsers used in CrossAssetModelBuilder's fromXML
+//! Enum parsers
 LgmData::ReversionType parseReversionType(const string& s);
 LgmData::VolatilityType parseVolatilityType(const string& s);
+QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping parseFloatSpreadMapping(const string& s);
 
-//! Enum to string used in CrossAssetModelBuilder's toXML
+//! Enum to string
 std::ostream& operator<<(std::ostream& oss, const LgmData::ReversionType& type);
 std::ostream& operator<<(std::ostream& oss, const LgmData::VolatilityType& type);
+std::ostream& operator<<(std::ostream& oss, const QuantExt::AnalyticLgmSwaptionEngine::FloatSpreadMapping& m);
 
 /*! LGM reversion transformation.
     

OREData/ored/portfolio/builders/scriptedtrade.cpp

@@ -1477,11 +1477,15 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
             std::vector<CalibrationBasket> calBaskets(1, CalibrationBasket(calInstr));
             if (infModelType_ == "DK") {
                 // build DK config
+                std::string infName = IndexInfo(modelInfIndices_[i].first).infName();
+                Real vol = parseReal(modelParameter("InfDkVolatility",
+                                                    {resolvedProductTag_ + "_" + infName, infName, resolvedProductTag_},
+                                                    false, "0.0050"));
                 config = QuantLib::ext::make_shared<InfDkData>(
                     CalibrationType::Bootstrap, calBaskets, modelInfIndices_[i].second->currency().code(),
                     IndexInfo(modelInfIndices_[i].first).infName(),
                     ReversionParameter(LgmData::ReversionType::Hagan, true, ParamType::Piecewise, {}, {0.60}),
-                    VolatilityParameter(LgmData::VolatilityType::Hagan, false, ParamType::Piecewise, {}, {0.0050}),
+                    VolatilityParameter(LgmData::VolatilityType::Hagan, false, ParamType::Piecewise, {}, {vol}),
                     LgmReversionTransformation(),
                     // ignore duplicate expiry times among calibration instruments
                     true);

OREData/ored/portfolio/builders/swaption.cpp

@@ -104,6 +104,8 @@ QuantLib::ext::shared_ptr<QuantExt::LGM> LGMSwaptionEngineBuilder::model(const s
     bool continueOnCalibrationError = globalParameters_.count("ContinueOnCalibrationError") > 0 &&
                                       parseBool(globalParameters_.at("ContinueOnCalibrationError"));
 
+    auto floatSpreadMapping = parseFloatSpreadMapping(modelParameter("FloatSpreadMapping", {}, false, "proRata"));
+
     auto data = QuantLib::ext::make_shared<IrLgmData>();
 
     // check for allowed calibration / bermudan strategy settings
@@ -138,6 +140,7 @@ QuantLib::ext::shared_ptr<QuantExt::LGM> LGMSwaptionEngineBuilder::model(const s
     data->volatilityType() = volatilityType;
     data->calibrationType() = calibration;
     data->shiftHorizon() = shiftHorizon;
+    data->floatSpreadMapping() = floatSpreadMapping;
 
     std::vector<Date> effExpiries;
     std::vector<Real> effStrikes;