QPR-13659 start delay for inflation swaps

Author: mgroncki

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/utilities/inflationstartdate.cpp

@@ -25,26 +25,33 @@ using QuantLib::Period;
 using QuantLib::Days;
 
 std::pair<QuantLib::Date, QuantLib::Period> getStartAndLag(const QuantLib::Date& asof,
-                                                           const InflationSwapConvention& conv) {
+                                                           const InflationSwapConvention& conv, const int startDelay,
+                                                           const Calendar& cal,
+                                                           const BusinessDayConvention startDelayConvention) {
+
+    Date adjustedAsOf = asof;
+    if (startDelay != 0) {
+        adjustedAsOf = cal.advance(asof, startDelay * Days, 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);
 }

OREData/ored/utilities/inflationstartdate.hpp

@@ -33,9 +33,10 @@ namespace data {
 // convention. In general, we take this simply to be (as of date, Period()). However, for AU CPI for
 // example, this is more complicated and we need to account for this here if the inflation swap conventions provide
 // us with a publication schedule and tell us to roll on that schedule.
-std::pair<QuantLib::Date, QuantLib::Period> getStartAndLag(const QuantLib::Date& asof,
-                                                           const InflationSwapConvention& conv);
-
+std::pair<QuantLib::Date, QuantLib::Period>
+getStartAndLag(const QuantLib::Date& asof, const InflationSwapConvention& conv, const int startDelay = 0,
+               const Calendar& cal = Calendar(),
+               const BusinessDayConvention startDelayConvention = BusinessDayConvention::Unadjusted);
 
 QuantLib::Date getInflationSwapStart(const QuantLib::Date& asof, const InflationSwapConvention& conv);