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

Author: Sjogren

ORE-SWIG/QuantLib-SWIG

@@ -171,7 +171,10 @@ void CrifAnalyticImpl::setUpConfigurations() {
     QL_REQUIRE(analytic()->configurations().simMarketParams, "CrifAnalytic: simMarketParams not set");
     QL_REQUIRE(analytic()->configurations().sensiScenarioData, "CrifAnalytic: sensiScenarioData not set");
     QL_REQUIRE(analytic()->configurations().todaysMarketParams, "CrifAnalytic: todaysMarketParams not set");
-    
+
+    inputs_->loadParameter<bool>(applySimmExemptions_, "crif", "applySimmExemptions", false,
+                                 std::function<bool(const string&)>(parseBool));
+
     setGenerateAdditionalResults(true);
 }
 
@@ -208,15 +211,19 @@ void CrifAnalyticImpl::runAnalytic(const QuantLib::ext::shared_ptr<ore::data::In
     analytic()->addReport(LABEL, "npv_no_simm_exemptions", npvWithoutReport);
 
     std::set<std::string> removedTrades, modifiedTrades;
-    analytic()->startTimer("applySimmExemptions()");
-    try {
-        std::tie(removedTrades, modifiedTrades) =
-            applySimmExemptions(*analytic()->portfolio(), engineFactory(), crifAnalytic->simmExemptionOverrides(),
-                                inputs_->useAtParCouponsTrades());
-    } catch (std::exception& e) {
-        QL_FAIL(e.what());
+    if (applySimmExemptions_) {
+        analytic()->startTimer("applySimmExemptions()");
+        try {
+            std::tie(removedTrades, modifiedTrades) =
+                applySimmExemptions(*analytic()->portfolio(), engineFactory(), crifAnalytic->simmExemptionOverrides(),
+                                    inputs_->useAtParCouponsTrades());
+        } catch (std::exception& e) {
+            QL_FAIL(e.what());
+        }
+        analytic()->stopTimer("applySimmExemptions()");
+    } else {
+        WLOG("Skipping application of SIMM exemptions as applySimmExemptions is set to false");
     }
-    analytic()->stopTimer("applySimmExemptions()");
 
     // If we have an empty portfolio, then quit the CRIF analytic
     if (analytic()->portfolio()->size() == 0) {

OREAnalytics/orea/app/analytics/crifanalytic.cpp

@@ -45,6 +45,9 @@ class CrifAnalyticImpl : public Analytic::Impl {
     void runAnalytic(const QuantLib::ext::shared_ptr<ore::data::InMemoryLoader>& loader,
                      const std::set<std::string>& runTypes = {}) override;
     void setUpConfigurations() override;
+
+private:
+    bool applySimmExemptions_ = true;
 };
 
 

OREAnalytics/orea/app/analytics/crifanalytic.hpp

@@ -23,7 +23,7 @@
 #pragma once
 
 #include <orea/app/marketdataloader.hpp>
-#include <ql/tuple.hpp>
+#include <tuple>
 
 namespace ore {
 namespace analytics {

OREAnalytics/orea/app/dummymarketdataloader.hpp

@@ -373,7 +373,8 @@ void MarketRiskBacktest::createReports(const ext::shared_ptr<MarketRiskReport::R
         if (pnl) {
             for (const auto& t : pnlColumns())
                 pnl->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
-            pnl->addColumn("DiscountSpec", string());
+            pnl->addColumn("DiscountSpecKey1", string());
+            pnl->addColumn("DiscountSpecKey2", string());
         }
     }
 
@@ -383,7 +384,8 @@ void MarketRiskBacktest::createReports(const ext::shared_ptr<MarketRiskReport::R
             pnlTrade->addColumn("TradeId", string());
             for (const auto& t : pnlColumns())
                 pnlTrade->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
-            pnlTrade->addColumn("DiscountSpec", string());
+            pnlTrade->addColumn("DiscountSpecKey1", string());
+            pnlTrade->addColumn("DiscountSpecKey2", string());
         }
     }
 }
@@ -458,16 +460,29 @@ void MarketRiskBacktest::addPnlRow(const QuantLib::ext::shared_ptr<BacktestRepor
         .add(currency.empty() ? calculationCurrency_ : currency);
 
     // Append DiscountSpec column (from TodaysMarketParameters) if available and applicable
-    std::string discountSpecStr;
+    std::string discountSpecStr1;
     if (todaysmarket_ && key_1.keytype == QuantExt::RiskFactorKey::KeyType::DiscountCurve) {
         const auto& discMap = todaysmarket_->mapping(ore::data::MarketObject::DiscountCurve, ore::data::Market::defaultConfiguration);
         auto it = discMap.find(key_1.name);
         if (it != discMap.end()){
-            discountSpecStr = it->second;
-        }     
+            discountSpecStr1 = it->second;
+        }
+    }
+    if (!discountSpecStr1.empty())
+        report.add(discountSpecStr1);
+    else
+        report.add(string());
+
+    std::string discountSpecStr2;
+    if (todaysmarket_ && key_2.keytype == QuantExt::RiskFactorKey::KeyType::DiscountCurve) {
+        const auto& discMap = todaysmarket_->mapping(ore::data::MarketObject::DiscountCurve, ore::data::Market::defaultConfiguration);
+        auto it = discMap.find(key_2.name);
+        if (it != discMap.end()){
+            discountSpecStr2 = it->second;
+        }
     }
-    if (!discountSpecStr.empty())
-        report.add(discountSpecStr);
+    if (!discountSpecStr2.empty())
+        report.add(discountSpecStr2);
     else
         report.add(string());
 }

OREAnalytics/orea/engine/marketriskbacktest.cpp

@@ -1798,11 +1798,9 @@ QuantLib::ext::shared_ptr<Instrument> ParSensitivityInstrumentBuilder::makeYoyIn
             discountCurve = market->discountCurve(ccy, marketConfiguration);
         }
     }
-    QL_DEPRECATED_DISABLE_WARNING
     QuantLib::ext::shared_ptr<YearOnYearInflationSwap> helper(new YearOnYearInflationSwap(
         YearOnYearInflationSwap::Payer, 1.0, fixSchedule, 0.0, conv->dayCounter(), yoySchedule, index,
-        conv->observationLag(), 0.0, conv->dayCounter(), conv->infCalendar()));
-    QL_DEPRECATED_ENABLE_WARNING
+        conv->observationLag(), QuantLib::CPI::AsIndex, 0.0, conv->dayCounter(), conv->infCalendar()));
     QuantLib::ext::shared_ptr<InflationCouponPricer> yoyCpnPricer =
         QuantLib::ext::make_shared<YoYInflationCouponPricer>(discountCurve);
     for (auto& c : helper->yoyLeg()) {
@@ -1879,12 +1877,11 @@ void ParSensitivityInstrumentBuilder::makeYoYCapFloor(ParSensitivityInstrumentBu
     }
 
     // build the leg data and instrument
-    QL_DEPRECATED_DISABLE_WARNING
-    Leg yoyLeg = yoyInflationLeg(yoySchedule, yoySchedule.calendar(), index, conv->observationLag())
-                     .withNotionals(1.0)
-                     .withPaymentDayCounter(conv->dayCounter())
-                     .withRateCurve(discountCurve);
-    QL_DEPRECATED_ENABLE_WARNING
+    Leg yoyLeg =
+        yoyInflationLeg(yoySchedule, yoySchedule.calendar(), index, conv->observationLag(), QuantLib::CPI::AsIndex)
+            .withNotionals(1.0)
+            .withPaymentDayCounter(conv->dayCounter())
+            .withRateCurve(discountCurve);
     if (market == nullptr)
         return;
 

OREAnalytics/orea/engine/parsensitivityinstrumentbuilder.cpp

@@ -270,9 +270,9 @@ void SaccrCalculator::aggregate() {
     DLOG("SA-CCR: Hedging set AddOn calculation");
     for (map<HedgingSetKey, Real>::iterator it = addOnHedgingSet_.begin(); it != addOnHedgingSet_.end(); it++) {
         // Add-ons
-        const NettingSetDetails& nettingSetDetails = QuantLib::ext::get<0>(it->first);
-        const AssetClass& assetClass = QuantLib::ext::get<1>(it->first);
-        const string& hedgingSet = QuantLib::ext::get<2>(it->first);
+        const NettingSetDetails& nettingSetDetails = std::get<0>(it->first);
+        const AssetClass& assetClass = std::get<1>(it->first);
+        const string& hedgingSet = std::get<2>(it->first);
         if (assetClass == AssetClass::IR) {
             // effectiveNotional_[it->first] =
             //     sqrt(D1 * D1 + D2 * D2 + D3 * D3 + 1.4 * (D1 * D2 + D2 * D3) + 0.6 * D1 * D3);
@@ -290,12 +290,12 @@ void SaccrCalculator::aggregate() {
             Real addonType = 0;
             Real addonTypeSquared = 0;
             for (const auto& [hedgingSubsetKey, effectiveNotional] : subsetEffectiveNotional_) {
-                HedgingSetKey hedgingSetKey(QuantLib::ext::get<0>(hedgingSubsetKey),
-                                            QuantLib::ext::get<1>(hedgingSubsetKey),
-                                            QuantLib::ext::get<2>(hedgingSubsetKey));
+                HedgingSetKey hedgingSetKey(std::get<0>(hedgingSubsetKey),
+                                            std::get<1>(hedgingSubsetKey),
+                                            std::get<2>(hedgingSubsetKey));
                 if (hedgingSetKey != it->first)
                     continue;
-                const string& hedgingSubset = QuantLib::ext::get<3>(hedgingSubsetKey);
+                const string& hedgingSubset = std::get<3>(hedgingSubsetKey);
                 vector<string> tokens;
                 boost::split(tokens, hedgingSubset, boost::is_any_of("_"));
                 QL_REQUIRE(tokens.size() == 1 || tokens.size() == 2,
@@ -319,10 +319,10 @@ void SaccrCalculator::aggregate() {
             Real addonType = 0;
             Real addonTypeSquared = 0;
             for (const auto& [hedgingSubsetKey, effectiveNotional] : subsetEffectiveNotional_) {
-                string hedgingSubset = QuantLib::ext::get<3>(hedgingSubsetKey);
-                HedgingSetKey hedgingSetKey(QuantLib::ext::get<0>(hedgingSubsetKey),
-                                            QuantLib::ext::get<1>(hedgingSubsetKey),
-                                            QuantLib::ext::get<2>(hedgingSubsetKey));
+                string hedgingSubset = std::get<3>(hedgingSubsetKey);
+                HedgingSetKey hedgingSetKey(std::get<0>(hedgingSubsetKey),
+                                            std::get<1>(hedgingSubsetKey),
+                                            std::get<2>(hedgingSubsetKey));
                 if (hedgingSetKey != it->first)
                     continue;
                 bool isEquityIndex = isIndex_[hedgingSubset];
@@ -352,9 +352,9 @@ void SaccrCalculator::aggregate() {
     DLOG("SA-CCR: Asset Class AddOn calculation");
     for (map<AssetClassKey, Real>::iterator it = addOnAssetClass_.begin(); it != addOnAssetClass_.end(); it++) {
         for (map<HedgingSetKey, Real>::iterator ith = addOnHedgingSet_.begin(); ith != addOnHedgingSet_.end(); ith++) {
-            NettingSetDetails nettingSetDetails = QuantLib::ext::get<0>(ith->first);
-            AssetClass assetClass = QuantLib::ext::get<1>(ith->first);
-            // string hedgingSet = QuantLib::ext::get<2>(it->first);
+            NettingSetDetails nettingSetDetails = std::get<0>(ith->first);
+            AssetClass assetClass = std::get<1>(ith->first);
+            // string hedgingSet = std::get<2>(it->first);
             AssetClassKey key(nettingSetDetails, assetClass);
             if (it->first != key)
                 continue;
@@ -421,12 +421,12 @@ void SaccrCalculator::aggregate() {
 
     hedgingSets_.clear();
     for (map<HedgingSetKey, Real>::iterator it = addOnHedgingSet_.begin(); it != addOnHedgingSet_.end(); it++) {
-        NettingSetDetails nettingSetDetails = QuantLib::ext::get<0>(it->first);
-        AssetClass ac = QuantLib::ext::get<1>(it->first);
+        NettingSetDetails nettingSetDetails = std::get<0>(it->first);
+        AssetClass ac = std::get<1>(it->first);
         pair<NettingSetDetails, AssetClass> key(nettingSetDetails, ac);
         if (hedgingSets_.find(key) == hedgingSets_.end())
             hedgingSets_[key] = vector<string>();
-        hedgingSets_[key].push_back(QuantLib::ext::get<2>(it->first));
+        hedgingSets_[key].push_back(std::get<2>(it->first));
     }
 
     if (reports_.size() > 0)

OREAnalytics/orea/engine/saccrcalculator.cpp

@@ -26,7 +26,7 @@
 #include <utility> // pair
 #include <vector>
 
-#include <ql/tuple.hpp>
+#include <tuple>
 #include <boost/tuple/tuple_comparison.hpp>
 
 #include <ql/time/period.hpp>

OREAnalytics/orea/engine/smrc.hpp

@@ -22,7 +22,7 @@
 #include <ored/utilities/log.hpp>
 #include <ql/errors.hpp>
 #include <ql/math/comparison.hpp>
-#include <ql/tuple.hpp>
+#include <tuple>
 #include <boost/math/distributions/normal.hpp>
 #include <ored/utilities/parsers.hpp>
 #include <ored/utilities/to_string.hpp>
@@ -244,9 +244,9 @@ QuantLib::Real StandardApproachCvaCalculator::getHedgeSensi(const CvaRiskFactorK
         return 0.0;
     } else {
         auto& indexRiskFactor = cvaNetSensitivities_.get<CvaRiskFactorTag>();
-        if (indexRiskFactor.count(QuantLib::ext::make_tuple("", rt, b, mt, rf, CvaType::CvaHedge)) == 0)
+        if (indexRiskFactor.count(std::make_tuple("", rt, b, mt, rf, CvaType::CvaHedge)) == 0)
             QL_FAIL("no hedge sensitivity found for " << rt << " " << b << " " << mt << " " << rf << " ");
-        auto it = indexRiskFactor.find(QuantLib::ext::make_tuple("", rt, b, mt, rf, CvaType::CvaHedge));
+        auto it = indexRiskFactor.find(std::make_tuple("", rt, b, mt, rf, CvaType::CvaHedge));
         return it->value;
     }
 }
@@ -272,7 +272,7 @@ void StandardApproachCvaCalculator::calculate() {
             for (auto mt : marginTypes) {
                 set<std::string> buckets;
                 set<std::string> riskFactors;
-                auto p = indexRiskType.equal_range(QuantLib::ext::make_tuple(n, rt, mt));
+                auto p = indexRiskType.equal_range(std::make_tuple(n, rt, mt));
                 while (p.first != p.second) {
                     buckets.insert(p.first->bucket);
                     checkRiskFactor(rt, mt, p.first->riskFactor);
@@ -285,8 +285,8 @@ void StandardApproachCvaCalculator::calculate() {
                     map<string, Real> ws;
                     vector<Real> ws_hdg;
                     for (auto rf : riskFactors) {
-                        if (indexRiskFactor.count(QuantLib::ext::make_tuple(n, rt, b, mt, rf, CvaType::CvaAggregate)) != 0) { 
-                            auto it = indexRiskFactor.find(QuantLib::ext::make_tuple(n, rt, b, mt, rf, CvaType::CvaAggregate));
+                        if (indexRiskFactor.count(std::make_tuple(n, rt, b, mt, rf, CvaType::CvaAggregate)) != 0) { 
+                            auto it = indexRiskFactor.find(std::make_tuple(n, rt, b, mt, rf, CvaType::CvaAggregate));
                             Real sk_cva = it->value;
                             Real sk_hdg = getHedgeSensi(rt, b, mt, rf, sk_cva);
                             Real rw = getRiskWeight(rt, b, mt, rf);

OREAnalytics/orea/engine/standardapproachcvacalculator.cpp

@@ -2636,7 +2636,7 @@ ScenarioSimMarket::ScenarioSimMarket(
                         }
 
                         for (Size i = 1; i < yoyCurveTimes.size(); i++) {
-                            Real rate = yoyInflationTs->yoyRate(quoteDates[i - 1], yoyInflationTs->observationLag());
+                            Real rate = yoyInflationTs->yoyRate(quoteDates[i - 1] - yoyInflationTs->observationLag());
                             auto q = QuantLib::ext::make_shared<SimpleQuote>(useSpreadedTermStructures_ ? 0.0 : rate);
                             if (i == 1) {
                                 // add the zero rate at first tenor to the T0 time, to ensure flat interpolation of T1