Merge remote-tracking branch 'origin/master' into feature/martin_docs1

Author: Sjogren

Docs/UserGuide/parameterisation/conventions.tex

@@ -641,6 +641,8 @@ \subsubsection{Inflation Swap Conventions}
   <AdjustInflationObservationDates>false</AdjustInflationObservationDates>
   <InflationCalendar>TARGET</InflationCalendar>
   <InflationConvention>MF</InflationConvention>
+  <StartDelay>2</StartDelay>
+  <StartDelayConvention>Following</StartDelayConvention>
 </InflationSwap>
 \end{minted}
 \caption{Inflation swap conventions}
@@ -659,6 +661,8 @@ \subsubsection{Inflation Swap Conventions}
 \item \lstinline!AdjustInflationObservationDates!: Flag indicating whether index observation dates should be adjusted or not.
 \item \lstinline!InflationCalendar!: The calendar for the inflation leg of the swap.
 \item \lstinline!InflationConvention!: The rolling convention for the inflation leg of the swap.
+\item \lstinline!StartDelay!: [Optional] The inflation swap starts n business days after today, defaults to zero if omitted.
+\item \lstinline!StartDelayConvention!: [Optional] BusinessDayConvention to adjust the start day, defaults to Following if omitted.
 
 \item \lstinline!PublicationRoll!:
 This is an optional node taking the values \lstinline!None!, \lstinline!OnPublicationDate! or \lstinline!AfterPublicationDate!. If omitted, the value \lstinline!None! is used. Currently, our only known use case for a value other than \lstinline!None! is for Australian zero coupon inflation indexed swaps (ZCIIS). Here, the index is published quarterly on the last Wednesday of the month following the end of the reference quarter. The start date and maturity date of the market quoted ZCIIS roll to the next quarterly date after the publication date of the index. For example, the AU CPI value for Q3 2020, i.e.\ 1 Jul 2020 to 30 Sep 2020 was released on 28 Oct 2020. On 27 Oct 2020, before the index publication date, the market 5Y ZCIIS would start on 15 Sep 2020 and end on 15 Sep 2025 and reference the Q2 inflation index value. On 29 Oct 2020, after the index publication date, the market 5Y ZCIIS would start on 15 Dec 2020 and end on 15 Dec 2025 and reference the Q3 inflation index value. On the release date, i.e. 28 Oct 2020, the market ZCIIS that is set up is determined by whether the \lstinline!PublicationRoll! value is \lstinline!OnPublicationDate! or \lstinline!AfterPublicationDate!. If it is set to \lstinline!OnPublicationDate!, the swap rolls on this date and hence the market 5Y ZCIIS would start on 15 Dec 2020 and end on 15 Dec 2025 and reference the Q3 inflation index value. If it is set to \lstinline!AfterPublicationDate!, the swap does not roll on the publication date and instead rolls on the next day, and hence the market 5Y ZCIIS would start on 15 Sep 2020 and end on 15 Sep 2025 and reference the Q2 inflation index value. The publication schedule for the index must be provided in the \lstinline!PublicationSchedule! node if \lstinline!PublicationRoll! is not \lstinline!None!. An example of the AU CPI conventions set up is given in Listing \ref{lst:aucpi_inflation_conventions}.

OREData/ored/configuration/conventions.cpp

@@ -1313,7 +1313,6 @@ void CdsConvention::fromXML(XMLNode* node) {
     strPaysAtDefaultTime_ = XMLUtils::getChildValue(node, "PaysAtDefaultTime", true);
     strUpfrontSettlementDays_ = XMLUtils::getChildValue(node, "UpfrontSettlementDays", false);
     strLastPeriodDayCounter_ = XMLUtils::getChildValue(node, "LastPeriodDayCounter", false);
-
     build();
 }
 
@@ -1366,6 +1365,8 @@ void InflationSwapConvention::build() {
     adjustInfObsDates_ = parseBool(strAdjustInfObsDates_);
     infCalendar_ = parseCalendar(strInfCalendar_);
     infConvention_ = parseBusinessDayConvention(strInfConvention_);
+    startDelayConvention_ =
+        strStartDelayConvention_.empty() ? Following : parseBusinessDayConvention(strStartDelayConvention_);
     if (publicationRoll_ != PublicationRoll::None) {
         QL_REQUIRE(publicationScheduleData_, "Publication roll is " << publicationRoll_ << " for " << id() <<
             " so expect non-null publication schedule data.");
@@ -1389,7 +1390,9 @@ void InflationSwapConvention::fromXML(XMLNode* node) {
     strAdjustInfObsDates_ = XMLUtils::getChildValue(node, "AdjustInflationObservationDates", true);
     strInfCalendar_ = XMLUtils::getChildValue(node, "InflationCalendar", true);
     strInfConvention_ = XMLUtils::getChildValue(node, "InflationConvention", true);
-
+    startDelay_ = XMLUtils::getChildValueAsInt(node, "StartDelay", false, 0);
+    strStartDelayConvention_ = XMLUtils::getChildValue(node, "StartDelayConvention", false);
+    
     publicationRoll_ = PublicationRoll::None;
     if (XMLNode* n = XMLUtils::getChildNode(node, "PublicationRoll")) {
         publicationRoll_ = parseInflationSwapPublicationRoll(XMLUtils::getNodeValue(n));
@@ -1419,7 +1422,12 @@ XMLNode* InflationSwapConvention::toXML(XMLDocument& doc) const {
     XMLUtils::addChild(doc, node, "AdjustInflationObservationDates", strAdjustInfObsDates_);
     XMLUtils::addChild(doc, node, "InflationCalendar", strInfCalendar_);
     XMLUtils::addChild(doc, node, "InflationConvention", strInfConvention_);
-
+    if (startDelay_ != 0) {
+        XMLUtils::addChild(doc, node, "StartDelay", startDelay_);
+    }
+    if (!strStartDelayConvention_.empty()) {
+        XMLUtils::addChild(doc, node, "StartDelayConvention", strStartDelayConvention_);
+    }
     if (publicationRoll_ != PublicationRoll::None) {
         XMLUtils::addChild(doc, node, "PublicationRoll", to_string(publicationRoll_));
         QL_REQUIRE(publicationScheduleData_, "PublicationRoll is " << publicationRoll_ << " for "

OREData/ored/configuration/conventions.hpp

@@ -1157,7 +1157,7 @@ class InflationSwapConvention : public Convention {
     InflationSwapConvention(const string& id, const string& strFixCalendar, const string& strFixConvention,
                             const string& strDayCounter, const string& strIndex, const string& strInterpolated,
                             const string& strObservationLag, const string& strAdjustInfObsDates,
-                            const string& strInfCalendar, const string& strInfConvention,
+                            const string& strInfCalendar, const string& strInfConvention, 
                             PublicationRoll publicationRoll = PublicationRoll::None,
                             const QuantLib::ext::shared_ptr<ScheduleData>& publicationScheduleData = nullptr);
 
@@ -1173,6 +1173,8 @@ class InflationSwapConvention : public Convention {
     BusinessDayConvention infConvention() const { return infConvention_; }
     PublicationRoll publicationRoll() const { return publicationRoll_; }
     const Schedule& publicationSchedule() const { return publicationSchedule_; }
+    int startDelay() const { return startDelay_; }
+    BusinessDayConvention startDelayConvention() const { return startDelayConvention_; }    
 
     virtual void fromXML(XMLNode* node) override;
     virtual XMLNode* toXML(XMLDocument& doc) const override;
@@ -1189,6 +1191,8 @@ class InflationSwapConvention : public Convention {
     Calendar infCalendar_;
     BusinessDayConvention infConvention_;
     Schedule publicationSchedule_;
+    int startDelay_ = 0;
+    BusinessDayConvention startDelayConvention_ = BusinessDayConvention::Following;
 
     // Store the inputs
     string strFixCalendar_;
@@ -1200,6 +1204,8 @@ class InflationSwapConvention : public Convention {
     string strAdjustInfObsDates_;
     string strInfCalendar_;
     string strInfConvention_;
+    string strStartDelayConvention_;
+    
     PublicationRoll publicationRoll_;
     QuantLib::ext::shared_ptr<ScheduleData> publicationScheduleData_;
 };

OREData/ored/portfolio/builders/deltagammaengines.hpp

@@ -170,15 +170,16 @@ class FxForwardEngineBuilderDeltaGamma : public FxForwardEngineBuilderBase {
         : FxForwardEngineBuilderBase("DiscountedCashflows", "DiscountingFxForwardEngineDeltaGamma") {}
 
 protected:
-    virtual QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy) override {
+    virtual QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy,
+                                                                const std::string& discountCurve) override {
 
         std::vector<Time> bucketTimes = parseListOfValues<Time>(engineParameter("BucketTimes"), &parseReal);
         bool computeDelta = parseBool(engineParameter("ComputeDelta"));
         bool computeGamma = parseBool(engineParameter("ComputeGamma"));
         bool linearInZero = parseBool(engineParameter("LinearInZero", {}, false, "True")); // FIXME: Add to pricing engine parameters?
         bool applySimmExemptions = parseBool(engineParameter("ApplySimmExemptions", {}, false, "false"));
 
-        string pair = keyImpl(forCcy, domCcy);
+        string pair = forCcy.code() + domCcy.code();
         Handle<YieldTermStructure> domCcyCurve =
             market_->discountCurve(domCcy.code(), configuration(MarketContext::pricing));
         Handle<YieldTermStructure> forCcyCurve =

OREData/ored/portfolio/builders/fxforward.cpp

@@ -29,7 +29,8 @@ using namespace QuantLib;
 using namespace QuantExt;
 
 QuantLib::ext::shared_ptr<PricingEngine> CamAmcFxForwardEngineBuilder::engineImpl(const Currency& forCcy,
-                                                                          const Currency& domCcy) {
+                                                                                  const Currency& domCcy,
+                                                                                  const std::string& discountCurve) {
 
     QL_REQUIRE(domCcy != forCcy, "CamAmcFxForwardEngineBuilder: domCcy = forCcy = " << domCcy.code());
 
@@ -76,7 +77,8 @@ QuantLib::ext::shared_ptr<PricingEngine> CamAmcFxForwardEngineBuilder::engineImp
 }
 
 QuantLib::ext::shared_ptr<PricingEngine> AmcCgFxForwardEngineBuilder::engineImpl(const Currency& forCcy,
-                                                                                 const Currency& domCcy) {
+                                                                                 const Currency& domCcy,
+                                                                                 const std::string& discountCurve) {
 
     QL_REQUIRE(domCcy != forCcy, "AmcCgFxForwardEngineBuilder: domCcy = forCcy = " << domCcy.code());
 

OREData/ored/portfolio/builders/fxforward.hpp

@@ -23,11 +23,14 @@
 
 #pragma once
 
-#include <boost/make_shared.hpp>
 #include <ored/portfolio/builders/cachingenginebuilder.hpp>
 #include <ored/portfolio/enginefactory.hpp>
+#include <ored/utilities/marketdata.hpp>
+
 #include <qle/pricingengines/discountingfxforwardengine.hpp>
 
+#include <boost/make_shared.hpp>
+
 namespace ore {
 namespace data {
 
@@ -36,15 +39,17 @@ namespace data {
     \ingroup builders
 */
 class FxForwardEngineBuilderBase
-    : public CachingPricingEngineBuilder<string, const Currency&, const Currency&> {
+    : public CachingPricingEngineBuilder<string, const Currency&, const Currency&, const string&> {
 public:
     FxForwardEngineBuilderBase(const std::string& model, const std::string& engine)
         : CachingEngineBuilder(model, engine, {"FxForward"}) {}
 
 protected:
-    string keyImpl(const Currency& forCcy, const Currency& domCcy) override {
-        return forCcy.code() + domCcy.code();
+    string keyImpl(const Currency& forCcy, const Currency& domCcy, const std::string& discountCurve) override {
+        return forCcy.code() + domCcy.code() + "_" + discountCurve;
     }
+
+    std::string discountCurve_;
 };
 
 //! Engine Builder for FX Forwards
@@ -56,12 +61,16 @@ class FxForwardEngineBuilder : public FxForwardEngineBuilderBase {
     FxForwardEngineBuilder() : FxForwardEngineBuilderBase("DiscountedCashflows", "DiscountingFxForwardEngine") {}
 
 protected:
-    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy) override {
-        string pair = keyImpl(forCcy, domCcy);
+    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy,
+                                                        const std::string& discountCurve) override {
+        std::cout << "getting curve '" << discountCurve << "'" << std::endl;
+        string pair = forCcy.code() + domCcy.code();
         return QuantLib::ext::make_shared<QuantExt::DiscountingFxForwardEngine>(
             domCcy, market_->discountCurve(domCcy.code(), configuration(MarketContext::pricing)), forCcy,
             market_->discountCurve(forCcy.code(), configuration(MarketContext::pricing)),
-            market_->fxRate(pair, configuration(MarketContext::pricing)));
+            market_->fxRate(pair, configuration(MarketContext::pricing)), QuantLib::Date(), QuantLib::Date(),
+            discountCurve.empty() ? Handle<YieldTermStructure>{}
+                                  : indexOrYieldCurve(market_, discountCurve, configuration(MarketContext::pricing)));
     }
 };
 
@@ -75,7 +84,8 @@ class CamAmcFxForwardEngineBuilder : public FxForwardEngineBuilderBase {
           stickyCloseOutDates_(stickyCloseOutDates) {}
 
 protected:
-    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy) override;
+    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy,
+                                                        const std::string& discountCurve) override;
 
 private:
     const QuantLib::ext::shared_ptr<QuantExt::CrossAssetModel> cam_;
@@ -93,7 +103,8 @@ class AmcCgFxForwardEngineBuilder : public FxForwardEngineBuilderBase {
     }
 
 protected:
-    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy) override;
+    QuantLib::ext::shared_ptr<PricingEngine> engineImpl(const Currency& forCcy, const Currency& domCcy,
+                                                        const std::string& discountCurve) override;
 
 private:
     const QuantLib::ext::shared_ptr<ore::data::ModelCG> modelCg_;

OREData/ored/portfolio/fxforward.cpp

@@ -156,7 +156,8 @@ void FxForward::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFact
     instrument_.reset(new VanillaInstrument(instrument));
 
     // set pricing engine
-    instrument_->qlInstrument()->setPricingEngine(fxBuilder->engine(boughtCcy, soldCcy));
+    instrument_->qlInstrument()->setPricingEngine(
+        fxBuilder->engine(boughtCcy, soldCcy, envelope().additionalField("discount_curve", false)));
     setSensitivityTemplate(*fxBuilder);
     addProductModelEngine(*fxBuilder);
 

OREData/ored/portfolio/fxoption.cpp

@@ -178,7 +178,7 @@ void FxOption::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFacto
             QuantLib::ext::shared_ptr<EngineBuilder> builder = engineFactory->builder("FxForward");
             auto fxBuilder = QuantLib::ext::dynamic_pointer_cast<FxForwardEngineBuilderBase>(builder);
             QL_REQUIRE(fxBuilder, "FxOption::build(): internal error: could not cast to FxForwardEngineBuilderBase");
-            qlinstr->setPricingEngine(fxBuilder->engine(boughtCcy,soldCcy));
+            qlinstr->setPricingEngine(fxBuilder->engine(boughtCcy, soldCcy, {}));
             auto configuration = fxBuilder->configuration(MarketContext::pricing);
 
             maturity_ = expiryDate_;

OREData/ored/portfolio/fxswap.cpp

@@ -63,12 +63,12 @@ void FxSwap::build(const QuantLib::ext::shared_ptr<EngineFactory>& engineFactory
         QL_REQUIRE(builder, "No builder found for " << tradeType_);
         QuantLib::ext::shared_ptr<FxForwardEngineBuilderBase> fxBuilder =
             QuantLib::ext::dynamic_pointer_cast<FxForwardEngineBuilderBase>(builder);
-        instNear_->setPricingEngine(fxBuilder->engine(nearSoldCcy, nearBoughtCcy));
+        instNear_->setPricingEngine(fxBuilder->engine(nearSoldCcy, nearBoughtCcy, {}));
         setSensitivityTemplate(*fxBuilder);
         addProductModelEngine(*fxBuilder);
         instFar_.reset(
             new QuantExt::FxForward(farBoughtAmount_, nearSoldCcy, farSoldAmount_, nearBoughtCcy, farDate, false));
-        instFar_->setPricingEngine(fxBuilder->engine(nearSoldCcy, nearBoughtCcy));
+        instFar_->setPricingEngine(fxBuilder->engine(nearSoldCcy, nearBoughtCcy, {}));
 
         DLOG("FxSwap::build(): Near NPV = " << instNear_->NPV());
         DLOG("FxSwap::build(): Far NPV = " << instFar_->NPV());

OREData/ored/utilities/inflationstartdate.cpp

@@ -27,24 +27,29 @@ using QuantLib::Days;
 std::pair<QuantLib::Date, QuantLib::Period> getStartAndLag(const QuantLib::Date& asof,
                                                            const InflationSwapConvention& conv) {
 
+    Date adjustedAsOf = asof;
+    if (conv.startDelay() != 0) {
+        adjustedAsOf = conv.fixCalendar().advance(asof, conv.startDelay() * Days, conv.startDelayConvention());
+    }
+
     using IPR = InflationSwapConvention::PublicationRoll;
 
     // If no roll schedule, just return (as of, convention's obs lag).
     if (conv.publicationRoll() == IPR::None) {
-        return make_pair(asof, Period());
+        return make_pair(adjustedAsOf, Period());
     }
 
     // If there is a publication roll, call getStart to retrieve the date.
-    Date d = getInflationSwapStart(asof, conv);
+    Date d = getInflationSwapStart(adjustedAsOf, conv);
 
     // Date in inflation period related to the inflation index value.
     Date dateInPeriod = d - Period(conv.index()->frequency());
 
-    // Find period between dateInPeriod and asof. This will be the inflation curve's obsLag.
-    QL_REQUIRE(dateInPeriod < asof, "InflationCurve: expected date in inflation period ("
-                                        << io::iso_date(dateInPeriod) << ") to be before the as of date ("
-                                        << io::iso_date(asof) << ").");
-    Period curveObsLag = (asof - dateInPeriod) * Days;
+    // Find period between dateInPeriod and adjustedAsOf. This will be the inflation curve's obsLag.
+    QL_REQUIRE(dateInPeriod < adjustedAsOf, "InflationCurve: expected date in inflation period ("
+                                                << io::iso_date(dateInPeriod) << ") to be before the as of date ("
+                                                << io::iso_date(adjustedAsOf) << ").");
+    Period curveObsLag = (adjustedAsOf - dateInPeriod) * Days;
 
     return make_pair(d, curveObsLag);
 }