Merge branch 'QPR-13369' into 'master'

QPR-13369 add rounding to average commodity cashflows

Closes QPR-13369

See merge request qs/oreplus!2750

Author: pcaspers

Docs/UserGuide/tradecomponents/commodityfloatingleg.tex

@@ -242,6 +242,9 @@ \subsubsection{Commodity Floating Leg Data}
 \item \lstinline!FXIndex! [Optional]: If \lstinline!IsAveraged! is \emph{true} this node allows the fx conversion to be applied daily in the computation of averaged cash flows. It cannot be used with the \lstinline!Indexing! node.
 
 Allowable values:  See Table \ref{tab:fxindex_data} for supported fx indices.
+
+\item \lstinline|AvgPricePrecision| [Optional]: This is only applicable when averaging is enabled. Allowed values: non-negative integer. Specifies the number of decimal places to which the average price should be rounded.
+
 \end{itemize}
 
 \begin{listing}[h!]

OREData/ored/portfolio/commoditylegbuilder.cpp

@@ -619,7 +619,8 @@ Leg CommodityFloatingLegBuilder::buildLeg(
                   .withDailyExpiryOffset(dailyExpOffset)
                   .unrealisedQuantity(floatingLegData->unrealisedQuantity())
                   .withOffPeakPowerData(offPeakPowerData)
-                  .withFxIndex(fxIndex);
+                  .withFxIndex(fxIndex)
+                  .withAvgPricePrecision(floatingLegData->avgPricePrecision());
     } else {
         CommodityIndexedCashFlow::PaymentTiming paymentTiming = CommodityIndexedCashFlow::PaymentTiming::InArrears;
         if (floatingLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::CalculationPeriodStartDate) {

OREData/ored/portfolio/commoditylegdata.cpp

@@ -177,7 +177,7 @@ CommodityFloatingLegData::CommodityFloatingLegData()
       pricingLag_(0), isAveraged_(false), isInArrears_(true), futureMonthOffset_(0),
       deliveryRollDays_(0), includePeriodEnd_(true), excludePeriodStart_(true),
       hoursPerDay_(Null<Natural>()), useBusinessDays_(true), dailyExpiryOffset_(0),
-      unrealisedQuantity_(false), lastNDays_(Null<Natural>()), fxIndex_("") {}
+      unrealisedQuantity_(false), lastNDays_(Null<Natural>()), fxIndex_(""), avgPricePrecision_(QuantLib::Null<QuantLib::Natural>()) {}
 
 CommodityFloatingLegData::CommodityFloatingLegData(
     const string& name, CommodityPriceType priceType, const vector<Real>& quantities,
@@ -187,7 +187,8 @@ CommodityFloatingLegData::CommodityFloatingLegData(
     const string& pricingCalendar, Natural pricingLag, const vector<string>& pricingDates, bool isAveraged,
     bool isInArrears, Natural futureMonthOffset, Natural deliveryRollDays, bool includePeriodEnd,
     bool excludePeriodStart, Natural hoursPerDay, bool useBusinessDays, const string& tag,
-    Natural dailyExpiryOffset, bool unrealisedQuantity, QuantLib::Natural lastNDays, std::string fxIndex)
+    Natural dailyExpiryOffset, bool unrealisedQuantity, QuantLib::Natural lastNDays, std::string fxIndex, 
+    QuantLib::Natural avgPricePrecision)
     : LegAdditionalData(LegType::CommodityFloating, false), name_(name), priceType_(priceType), quantities_(quantities),
       quantityDates_(quantityDates), commodityQuantityFrequency_(commodityQuantityFrequency),
       commodityPayRelativeTo_(commodityPayRelativeTo), spreads_(spreads), spreadDates_(spreadDates),
@@ -196,7 +197,8 @@ CommodityFloatingLegData::CommodityFloatingLegData(
       isInArrears_(isInArrears), futureMonthOffset_(futureMonthOffset), deliveryRollDays_(deliveryRollDays),
       includePeriodEnd_(includePeriodEnd), excludePeriodStart_(excludePeriodStart), hoursPerDay_(hoursPerDay),
       useBusinessDays_(useBusinessDays), tag_(tag), dailyExpiryOffset_(dailyExpiryOffset),
-      unrealisedQuantity_(unrealisedQuantity), lastNDays_(lastNDays), fxIndex_(fxIndex) {
+      unrealisedQuantity_(unrealisedQuantity), lastNDays_(lastNDays), fxIndex_(fxIndex),
+      avgPricePrecision_(avgPricePrecision) {
     indices_.insert("COMM-" + name_);
 }
 
@@ -287,6 +289,12 @@ void CommodityFloatingLegData::fromXML(XMLNode* node) {
     if (XMLNode* n = XMLUtils::getChildNode(node, "FXIndex")) {
         fxIndex_ = XMLUtils::getNodeValue(n);
     }
+
+    if (XMLNode* n = XMLUtils::getChildNode(node, "AvgPricePrecision")) {
+        int precision = parseInteger(XMLUtils::getNodeValue(n));
+        QL_REQUIRE(precision >= 0, "CommodityFloatingLegData: avgPricePrecision must be non-negative, got " << precision);
+        avgPricePrecision_ = static_cast<QuantLib::Natural>(precision);
+    } 
 }
 
 XMLNode* CommodityFloatingLegData::toXML(XMLDocument& doc) const {
@@ -337,7 +345,9 @@ XMLNode* CommodityFloatingLegData::toXML(XMLDocument& doc) const {
         XMLUtils::addChild(doc, node, "LastNDays", static_cast<int>(lastNDays_));
     if (!fxIndex_.empty())
         XMLUtils::addChild(doc, node, "FXIndex", fxIndex_);
-
+    if (avgPricePrecision_ != Null<Natural>()) {
+        XMLUtils::addChild(doc, node, "AvgPricePrecision", static_cast<int>(avgPricePrecision_));
+    }
     return node;
 }
 

OREData/ored/portfolio/commoditylegdata.hpp

@@ -115,7 +115,8 @@ class CommodityFloatingLegData : public ore::data::LegAdditionalData {
         bool excludePeriodStart = true, QuantLib::Natural hoursPerDay = QuantLib::Null<QuantLib::Natural>(),
         bool useBusinessDays = true, const std::string& tag = "", QuantLib::Natural dailyExpiryOffset =
         QuantLib::Null<QuantLib::Natural>(), bool unrealisedQuantity = false,
-        QuantLib::Natural lastNDays = QuantLib::Null<QuantLib::Natural>(), std::string fxIndex = "");
+        QuantLib::Natural lastNDays = QuantLib::Null<QuantLib::Natural>(), std::string fxIndex = "",
+        QuantLib::Natural avgPricePrecision = QuantLib::Null<QuantLib::Natural>());
 
     //! \name Inspectors
     //@{
@@ -146,6 +147,7 @@ class CommodityFloatingLegData : public ore::data::LegAdditionalData {
     bool unrealisedQuantity() const { return unrealisedQuantity_; }
     QuantLib::Natural lastNDays() const { return lastNDays_; }
     std::string const& fxIndex() const { return fxIndex_; }
+    QuantLib::Natural avgPricePrecision() const { return avgPricePrecision_; }
     //@}
 
     //! \name Serialisation
@@ -182,6 +184,7 @@ class CommodityFloatingLegData : public ore::data::LegAdditionalData {
     bool unrealisedQuantity_;
     QuantLib::Natural lastNDays_;
     std::string fxIndex_;
+    QuantLib::Natural avgPricePrecision_;
 };
 
 } // namespace data

OREData/ored/portfolio/commodityswap.cpp

@@ -249,19 +249,16 @@ const std::map<std::string,boost::any>& CommoditySwap::additionalData() const {
                     std::vector<Real> priceVec;
                     std::vector<std::string> indexVec;
                     std::vector<Date> indexExpiryVec, pricingDateVec;
-                    double averagePrice = 0;
                     for (const auto& kv : indexedAvgFlow->indices()) {
                         indexVec.push_back(kv.second->name());
                         indexExpiryVec.push_back(kv.second->expiryDate());
                         pricingDateVec.push_back(kv.first);
                         priceVec.push_back(kv.second->fixing(kv.first));
-                        averagePrice += priceVec.back();
                     }
-                    averagePrice /= indexedAvgFlow->indices().size();
                     additionalData_["index[" + label + "]"] = indexVec;
                     additionalData_["indexExpiry[" + label + "]"] = indexExpiryVec;
                     additionalData_["price[" + label + "]"] = priceVec;
-                    additionalData_["averagePrice[" + label + "]"] = averagePrice;
+                    additionalData_["averagePrice[" + label + "]"] = indexedAvgFlow->fixing();
                     additionalData_["pricingDate[" + label + "]"] = pricingDateVec;
                     additionalData_["paymentDate[" + label + "]"] = to_string(indexedAvgFlow->date());
                 }

QuantExt/qle/cashflows/commodityindexedaveragecashflow.cpp

@@ -45,14 +45,14 @@ CommodityIndexedAverageCashFlow::CommodityIndexedAverageCashFlow(
     const ext::shared_ptr<FutureExpiryCalculator>& calc, bool includeEndDate, bool excludeStartDate,
     bool useBusinessDays, CommodityQuantityFrequency quantityFrequency, Natural hoursPerDay, Natural dailyExpiryOffset,
     bool unrealisedQuantity, const boost::optional<pair<Calendar, Real>>& offPeakPowerData,
-    const ext::shared_ptr<FxIndex>& fxIndex)
+    const ext::shared_ptr<FxIndex>& fxIndex, QuantLib::Natural avgPricePrecision)
     : CommodityCashFlow(quantity, spread, gearing, useFuturePrice, index, fxIndex), startDate_(startDate),
       endDate_(endDate),
       paymentDate_(paymentDate), pricingCalendar_(pricingCalendar), deliveryDateRoll_(deliveryDateRoll),
       futureMonthOffset_(futureMonthOffset), includeEndDate_(includeEndDate), excludeStartDate_(excludeStartDate),
       useBusinessDays_(useBusinessDays), quantityFrequency_(quantityFrequency), hoursPerDay_(hoursPerDay),
       dailyExpiryOffset_(dailyExpiryOffset), unrealisedQuantity_(unrealisedQuantity),
-      offPeakPowerData_(offPeakPowerData) {
+      offPeakPowerData_(offPeakPowerData), avgPricePrecision_(avgPricePrecision) {
     init(calc);
 }
 
@@ -64,13 +64,14 @@ CommodityIndexedAverageCashFlow::CommodityIndexedAverageCashFlow(
     const ext::shared_ptr<FutureExpiryCalculator>& calc, bool includeEndDate, bool excludeStartDate,
     const QuantLib::Date& paymentDateOverride, bool useBusinessDays, CommodityQuantityFrequency quantityFrequency,
     Natural hoursPerDay, Natural dailyExpiryOffset, bool unrealisedQuantity,
-    const boost::optional<pair<Calendar, Real>>& offPeakPowerData, const ext::shared_ptr<FxIndex>& fxIndex)
+    const boost::optional<pair<Calendar, Real>>& offPeakPowerData, const ext::shared_ptr<FxIndex>& fxIndex,
+    QuantLib::Natural avgPricePrecision)
     : CommodityCashFlow(quantity, spread, gearing, useFuturePrice, index, fxIndex), startDate_(startDate), endDate_(endDate),
       paymentDate_(paymentDateOverride), pricingCalendar_(pricingCalendar),
       deliveryDateRoll_(deliveryDateRoll), futureMonthOffset_(futureMonthOffset), includeEndDate_(includeEndDate),
       excludeStartDate_(excludeStartDate), useBusinessDays_(useBusinessDays), quantityFrequency_(quantityFrequency),
       hoursPerDay_(hoursPerDay), dailyExpiryOffset_(dailyExpiryOffset), unrealisedQuantity_(unrealisedQuantity),
-      offPeakPowerData_(offPeakPowerData) {
+      offPeakPowerData_(offPeakPowerData), avgPricePrecision_(avgPricePrecision)  {
 
     // Derive the payment date
     if (paymentDate_ == Date()) {
@@ -100,6 +101,11 @@ void CommodityIndexedAverageCashFlow::performCalculations() const {
         }
     }
 
+    if (avgPricePrecision_ != QuantLib::Null<QuantLib::Natural>()) {
+        QuantLib::ClosestRounding round(avgPricePrecision_);
+        averagePrice_ = round(averagePrice_);
+    }
+
     // Amount is just average price times quantity
     // In case of Foreign currency settlement, the spread must be expressed in Foreign currency units
     amount_ = periodQuantity_ * (gearing_ * averagePrice_ + spread_);
@@ -284,7 +290,7 @@ CommodityIndexedAverageLeg::CommodityIndexedAverageLeg(const Schedule& schedule,
       deliveryDateRoll_(0), futureMonthOffset_(0), payAtMaturity_(false), includeEndDate_(true),
       excludeStartDate_(true), useBusinessDays_(true),
       quantityFrequency_(CommodityQuantityFrequency::PerCalculationPeriod), hoursPerDay_(Null<Natural>()),
-      dailyExpiryOffset_(Null<Natural>()), unrealisedQuantity_(false) {}
+      dailyExpiryOffset_(Null<Natural>()), unrealisedQuantity_(false), avgPricePrecision_(Null<Natural>()) {}
 
 CommodityIndexedAverageLeg& CommodityIndexedAverageLeg::withQuantities(Real quantity) {
     quantities_ = vector<Real>(1, quantity);
@@ -419,6 +425,11 @@ CommodityIndexedAverageLeg& CommodityIndexedAverageLeg::withOffPeakPowerData(con
     return *this;
 }
 
+CommodityIndexedAverageLeg& CommodityIndexedAverageLeg::withAvgPricePrecision(QuantLib::Natural precision){
+    avgPricePrecision_ = precision;
+    return *this;
+}
+
 CommodityIndexedAverageLeg::operator Leg() const {
 
     // Number of commodity indexed average cashflows
@@ -469,7 +480,7 @@ CommodityIndexedAverageLeg::operator Leg() const {
             quantity, start, end, paymentLag_, paymentCalendar_, paymentConvention_, index_, pricingCalendar_, spread,
             gearing, paymentTiming_, useFuturePrice_, deliveryDateRoll_, futureMonthOffset_, calc_, includeEnd,
             excludeStart, paymentDate, useBusinessDays_, quantityFrequency_, hoursPerDay_, dailyExpiryOffset_,
-            unrealisedQuantity_, offPeakPowerData_, fxIndex_));
+            unrealisedQuantity_, offPeakPowerData_, fxIndex_, avgPricePrecision_));
     }
 
     return leg;

QuantExt/qle/cashflows/commodityindexedaveragecashflow.hpp

@@ -60,7 +60,7 @@ class CommodityIndexedAverageCashFlow : public CommodityCashFlow {
         QuantLib::Natural hoursPerDay = QuantLib::Null<QuantLib::Natural>(),
         QuantLib::Natural dailyExpiryOffset = QuantLib::Null<QuantLib::Natural>(), bool unrealisedQuantity = false,
         const boost::optional<std::pair<QuantLib::Calendar, QuantLib::Real>>& offPeakPowerData = boost::none,
-        const ext::shared_ptr<FxIndex>& fxIndex = nullptr);
+        const ext::shared_ptr<FxIndex>& fxIndex = nullptr, QuantLib::Natural avgPricePrecision = QuantLib::Null<QuantLib::Natural>());
 
     //! Constructor that deduces payment date from \p endDate using payment conventions
     CommodityIndexedAverageCashFlow(
@@ -76,7 +76,7 @@ class CommodityIndexedAverageCashFlow : public CommodityCashFlow {
         QuantLib::Natural hoursPerDay = QuantLib::Null<QuantLib::Natural>(),
         QuantLib::Natural dailyExpiryOffset = QuantLib::Null<QuantLib::Natural>(), bool unrealisedQuantity = false,
         const boost::optional<std::pair<QuantLib::Calendar, QuantLib::Real>>& offPeakPowerData = boost::none,
-        const ext::shared_ptr<FxIndex>& fxIndex = nullptr);
+        const ext::shared_ptr<FxIndex>& fxIndex = nullptr, QuantLib::Natural avgPricePrecision = QuantLib::Null<QuantLib::Natural>());
 
     //! \name Inspectors
     //@{
@@ -159,7 +159,7 @@ class CommodityIndexedAverageCashFlow : public CommodityCashFlow {
     QuantLib::Real periodQuantity_;
     boost::optional<std::pair<QuantLib::Calendar, QuantLib::Real>> offPeakPowerData_;
     mutable QuantLib::Real averagePrice_;
-
+    QuantLib::Natural avgPricePrecision_;
     // Populated only when offPeakPowerData_ is provided.
     std::map<QuantLib::Date, QuantLib::Real> weights_;
 
@@ -203,7 +203,7 @@ class CommodityIndexedAverageLeg {
     CommodityIndexedAverageLeg&
     withOffPeakPowerData(const boost::optional<std::pair<QuantLib::Calendar, QuantLib::Real>>& offPeakPowerData);
     CommodityIndexedAverageLeg& withFxIndex(const ext::shared_ptr<FxIndex>& fxIndex);
-
+    CommodityIndexedAverageLeg& withAvgPricePrecision(QuantLib::Natural precision =  QuantLib::Null<QuantLib::Natural>());
     operator Leg() const;
 
 private:
@@ -232,6 +232,7 @@ class CommodityIndexedAverageLeg {
     bool unrealisedQuantity_;
     boost::optional<std::pair<QuantLib::Calendar, QuantLib::Real>> offPeakPowerData_;
     ext::shared_ptr<FxIndex> fxIndex_;
+    QuantLib::Natural avgPricePrecision_;
 };
 
 } // namespace QuantExt

xsd/instruments.xsd

@@ -1043,6 +1043,7 @@
         <xs:element type="xs:positiveInteger" name="LastNDays" minOccurs="0" maxOccurs="1"/>
         <xs:element type="xs:string" name="Tag" minOccurs="0" maxOccurs="1"/>
         <xs:element type="xs:string" name="FXIndex" minOccurs="0"/>
+        <xs:element type="xs:nonNegativeInteger" name="AvgPricePrecision" minOccurs="0"/>
       </xs:all>
     </xs:complexType>
   </xs:element>