QPR-12397 some speed optimizations if there are many qualifiers / buckets

NathanielVolfango · jenkins · commit 86081af332f5 · 2024-04-08T10:40:52.000Z
diff --git a/OREAnalytics/orea/simm/simmbucketmapperbase.cpp b/OREAnalytics/orea/simm/simmbucketmapperbase.cpp
@@ -103,6 +103,10 @@ QuantLib::Date BucketMapping::validFromDate() const {
 
 string SimmBucketMapperBase::bucket(const RiskType& riskType, const string& qualifier) const {
 
+    auto key = std::make_pair(riskType, qualifier);
+    if (auto b = cache_.find(key); b != cache_.end())
+        return b->second;
+
     QL_REQUIRE(hasBuckets(riskType), "The risk type " << riskType << " does not have buckets");
 
     // Vol risk type bucket mappings are stored in their non-vol counterparts
@@ -114,7 +118,9 @@ string SimmBucketMapperBase::bucket(const RiskType& riskType, const string& qual
 
     // Deal with RiskType::IRCurve
     if (lookupRiskType == RiskType::IRCurve || lookupRiskType == RiskType::GIRR_DELTA) {
-        return irBucket(qualifier);
+        auto tmp = irBucket(qualifier);
+        cache_[key] = tmp;
+        return tmp;
     }
 
     string bucket;
@@ -186,13 +192,15 @@ string SimmBucketMapperBase::bucket(const RiskType& riskType, const string& qual
         for (auto m : bucketMapping_.at(lookupRiskType).at(lookupName)) {
             if (m.validToDate() >= today && m.validFromDate() <= today && m.fallback() == !haveMapping) {
                 bucket = m.bucket();
+                cache_[key] = bucket;
                 return bucket;
             }
         }
         TLOG("bucket mapping for risk type " << riskType << " and qualifier " << qualifier << " inactive, return Residual");
         bucket = "Residual";
     }
 
+    cache_[key] = bucket;
     return bucket;
 }
 
@@ -332,6 +340,8 @@ XMLNode* SimmBucketMapperBase::toXML(ore::data::XMLDocument& doc) const {
 void SimmBucketMapperBase::addMapping(const RiskType& riskType, const string& qualifier, const string& bucket,
                                       const string& validFrom, const string& validTo, bool fallback) {
 
+    cache_.clear();
+
     // Possibly map to non-vol counterpart for lookup
     RiskType rt = riskType;
     if (nonVolRiskTypeMap.count(riskType) > 0) {
@@ -393,6 +403,7 @@ void SimmBucketMapperBase::checkRiskType(const RiskType& riskType) const {
 }
 
 void SimmBucketMapperBase::reset() {
+    cache_.clear();
     // Clear the bucket mapper and add back the commodity mappings
     bucketMapping_.clear();
     failedMappings_.clear();
diff --git a/OREAnalytics/orea/simm/simmbucketmapperbase.hpp b/OREAnalytics/orea/simm/simmbucketmapperbase.hpp
@@ -115,6 +115,8 @@ class SimmBucketMapperBase : public SimmBucketMapper, public ore::data::XMLSeria
     std::set<CrifRecord::RiskType> rtWithBuckets_;
 
 private:
+    mutable std::map<std::pair<CrifRecord::RiskType, std::string>, std::string> cache_;
+
     //! Reset the SIMM bucket mapper i.e. clears all mappings and adds the initial hard-coded commodity mappings
     void reset();
 
diff --git a/OREAnalytics/orea/simm/simmcalculator.cpp b/OREAnalytics/orea/simm/simmcalculator.cpp
@@ -897,10 +897,16 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
 
     bool riskClassIsFX = rt == RiskType::FX || rt == RiskType::FXVol;
 
+    // precomputed
+    map<std::pair<std::string,std::string>, std::vector<CrifRecord>> crifByQualifierAndBucket;
+    map<std::string, std::vector<CrifRecord>> crifByBucket;
+
     // Find the set of buckets and associated qualifiers for the netting set details, product class and risk type
     map<string, set<string>> buckets;
     for(const auto& it : crif.filterBy(nettingSetDetails, pc, rt)) {
         buckets[it.bucket].insert(it.qualifier);
+        crifByQualifierAndBucket[std::make_pair(it.qualifier,it.bucket)].push_back(it);
+        crifByBucket[it.bucket].push_back(it);
     }
 
     // If there are no buckets, return early and set bool to false to indicate margin does not apply
@@ -925,7 +931,8 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
 
         // Get the concentration risk for each qualifier in current bucket i.e. $CR_k$ from SIMM docs
         map<string, Real> concentrationRisk;
-        for (const auto& qualifier : buckets.at(bucket)) {
+
+        for (const auto& qualifier : kv.second) {
 
             // Do not include Risk_FX components in the calculation currency in the SIMM calculation
             if (rt == RiskType::FX && qualifier == calcCcy) {
@@ -938,7 +945,7 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
             }
 
             // Pair of iterators to start and end of sensitivities with current qualifier
-            auto pQualifier = crif.filterByQualifierAndBucket(nettingSetDetails, pc, rt, qualifier, bucket);
+            auto pQualifier = crifByQualifierAndBucket[std::make_pair(qualifier,bucket)];
 
             // One pass to get the concentration risk for this qualifier
             for (auto it = pQualifier.begin(); it != pQualifier.end(); ++it) {
@@ -955,9 +962,10 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
             concentrationRisk[qualifier] = max(1.0, sqrt(std::abs(concentrationRisk[qualifier])));
         }
 
+
         // Calculate the margin component for the current bucket
         // Pair of iterators to start and end of sensitivities within current bucket
-        auto pBucket = crif.filterByBucket(nettingSetDetails, pc, rt, bucket);
+        auto pBucket = crifByBucket[bucket];
         for (auto itOuter = pBucket.begin(); itOuter != pBucket.end(); ++itOuter) {
             // Do not include Risk_FX components in the calculation currency in the SIMM calculation
             if (rt == RiskType::FX && itOuter->qualifier == calcCcy) {
@@ -975,6 +983,8 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
             // Weighted sensitivity i.e. $WS_{k}$ from SIMM docs
             Real wsOuter =
                 rwOuter * (itOuter->amountResultCcy * sigmaOuter * hvr) * concentrationRisk[itOuter->qualifier];
+            // Get concentration risk for outer qualifier
+            Real outerConcentrationRisk = concentrationRisk.at(itOuter->qualifier);
             // Update weighted sensitivity sum
             sumWeightedSensis[bucket] += wsOuter;
             // Add diagonal element to bucket margin
@@ -991,12 +1001,12 @@ pair<map<string, Real>, bool> SimmCalculator::margin(const NettingSetDetails& ne
                     continue;
                 }
                 // Correlation, $\rho_{k,l}$ in the SIMM docs
-                Real corr = simmConfiguration_->correlation(rt, itOuter->qualifier, itOuter->label1, itOuter->label2,
-                                                            rt, itInner->qualifier, itInner->label1, itInner->label2,
-                                                            calcCcy);
+                Real corr =
+                    simmConfiguration_->correlation(rt, itOuter->qualifier, itOuter->label1, itOuter->label2, rt,
+                                                    itInner->qualifier, itInner->label1, itInner->label2, calcCcy);
                 // $f_{k,l}$ from the SIMM docs
-                Real f = min(concentrationRisk.at(itOuter->qualifier), concentrationRisk.at(itInner->qualifier)) /
-                         max(concentrationRisk.at(itOuter->qualifier), concentrationRisk.at(itInner->qualifier));
+                Real f = min(outerConcentrationRisk, concentrationRisk.at(itInner->qualifier)) /
+                         max(outerConcentrationRisk, concentrationRisk.at(itInner->qualifier));
                 // Add cross element to delta margin
                 Real sigmaInner = simmConfiguration_->sigma(rt, itInner->qualifier, itInner->label1, calcCcy);
                 Real rwInner = simmConfiguration_->weight(rt, itInner->qualifier, itInner->label1, calcCcy);
diff --git a/OREAnalytics/orea/simm/simmconfigurationbase.cpp b/OREAnalytics/orea/simm/simmconfigurationbase.cpp
@@ -231,59 +231,32 @@ QuantLib::Real SimmConfigurationBase::correlation(const RiskType& firstRt, const
         return 1.0;
     }
 
-    // Deal with case of different risk types
-    if ((firstRt != secondRt) && (firstQualifier == secondQualifier)) {
-        if (((firstRt == RiskType::IRCurve || firstRt == RiskType::Inflation) && secondRt == RiskType::XCcyBasis) ||
-            (firstRt == RiskType::XCcyBasis && (secondRt == RiskType::IRCurve || secondRt == RiskType::Inflation))) {
-            // Between xccy basis and any yield or inflation in same currency
-            return xccyCorr_;
-        }
-        if ((firstRt == RiskType::IRCurve && secondRt == RiskType::Inflation) ||
-            (firstRt == RiskType::Inflation && secondRt == RiskType::IRCurve)) {
-            // Between any yield and inflation in same currency
-            return infCorr_;
-        }
-        if ((firstRt == RiskType::IRVol && secondRt == RiskType::InflationVol) ||
-            (firstRt == RiskType::InflationVol && secondRt == RiskType::IRVol)) {
-            // Between any yield volatility and inflation volatility in same currency
-            return infVolCorr_;
-        }
-    }
+    // Deal with Equity correlations
+    if ((firstRt == RiskType::Equity && secondRt == RiskType::Equity) ||
+        (firstRt == RiskType::EquityVol && secondRt == RiskType::EquityVol)) {
 
-    // Deal with IRCurve and IRVol correlations
-    if ((firstRt == RiskType::IRCurve && secondRt == RiskType::IRCurve) ||
-        (firstRt == RiskType::IRVol && secondRt == RiskType::IRVol)) {
+        // Get the bucket of each qualifier
+        string bucket_1 = simmBucketMapper_->bucket(firstRt, firstQualifier);
+        string bucket_2 = simmBucketMapper_->bucket(secondRt, secondQualifier);
 
-        // If the qualifiers, i.e. currencies, are the same
-        if (firstQualifier == secondQualifier) {
-            // Label2 level, i.e. sub-curve, correlations
-            if (firstLabel_2 != secondLabel_2) {
-                QL_REQUIRE(
-                    firstLabel_1 == "" && secondLabel_1 == "",
-                    "When asking for Label2 level correlations, "
-                        << "the Label1 level values should both contain the default parameter i.e. empty string");
-                QL_REQUIRE(firstRt != RiskType::IRVol, "There is no correlation at the Label2 level for Risk_IRVol");
-                return irSubCurveCorr_;
-            }
+        // Residual is special, 0 correlation inter and intra except if same qualifier
+        if (bucket_1 == "Residual" || bucket_2 == "Residual") {
+            return firstQualifier == secondQualifier ? 1.0 : 0.0;
+        }
 
-            // Label1 level, i.e. tenor, correlations
-            RiskType rt = RiskType::IRCurve;
-            auto label12Key = makeKey("", firstLabel_1, secondLabel_1);
-            if (intraBucketCorrelation_.at(rt).find(label12Key) != intraBucketCorrelation_.at(rt).end())
-                return intraBucketCorrelation_.at(rt).at(label12Key);
-            else
-                QL_FAIL("Could not find correlation for risk type " << rt << " and key " << label12Key);
+        // Non-residual
+        // Get the bucket index of each qualifier
+        if (bucket_1 == bucket_2) {
+            auto bucketKey = makeKey(bucket_1, "", "");
+            // If same bucket, return the intra-bucket correlation
+            return firstQualifier == secondQualifier ? 1.0 : intraBucketCorrelation_.at(RiskType::Equity).at(bucketKey);
         } else {
-            // If the qualifiers, i.e. currencies, are not the same
-            return irInterCurrencyCorr_;
+            // If different buckets, return the inter-bucket correlation
+            auto label12Key = makeKey("", bucket_1, bucket_2);
+            return interBucketCorrelation_.at(RiskType::Equity).at(label12Key);
         }
     }
 
-    // Deal with inflation volatility correlations
-    if (firstRt == RiskType::InflationVol && secondRt == RiskType::InflationVol) {
-        return 1.0;
-    }
-
     // Deal with CreditQ correlations
     if ((firstRt == RiskType::CreditQ && secondRt == RiskType::CreditQ) ||
         (firstRt == RiskType::CreditVol && secondRt == RiskType::CreditVol)) {
@@ -364,32 +337,6 @@ QuantLib::Real SimmConfigurationBase::correlation(const RiskType& firstRt, const
         }
     }
 
-    // Deal with Equity correlations
-    if ((firstRt == RiskType::Equity && secondRt == RiskType::Equity) ||
-        (firstRt == RiskType::EquityVol && secondRt == RiskType::EquityVol)) {
-
-        // Get the bucket of each qualifier
-        string bucket_1 = simmBucketMapper_->bucket(firstRt, firstQualifier);
-        string bucket_2 = simmBucketMapper_->bucket(secondRt, secondQualifier);
-
-        // Residual is special, 0 correlation inter and intra except if same qualifier
-        if (bucket_1 == "Residual" || bucket_2 == "Residual") {
-            return firstQualifier == secondQualifier ? 1.0 : 0.0;
-        }
-
-        // Non-residual
-        // Get the bucket index of each qualifier
-        if (bucket_1 == bucket_2) {
-            auto bucketKey = makeKey(bucket_1, "", "");
-            // If same bucket, return the intra-bucket correlation
-            return firstQualifier == secondQualifier ? 1.0 : intraBucketCorrelation_.at(RiskType::Equity).at(bucketKey);
-        } else {
-            // If different buckets, return the inter-bucket correlation
-            auto label12Key = makeKey("", bucket_1, bucket_2);
-            return interBucketCorrelation_.at(RiskType::Equity).at(label12Key);
-        }
-    }
-
     // Deal with Commodity correlations
     if ((firstRt == RiskType::Commodity && secondRt == RiskType::Commodity) ||
         (firstRt == RiskType::CommodityVol && secondRt == RiskType::CommodityVol)) {
@@ -409,6 +356,59 @@ QuantLib::Real SimmConfigurationBase::correlation(const RiskType& firstRt, const
         }
     }
 
+    // Deal with case of different risk types
+    if ((firstRt != secondRt) && (firstQualifier == secondQualifier)) {
+        if (((firstRt == RiskType::IRCurve || firstRt == RiskType::Inflation) && secondRt == RiskType::XCcyBasis) ||
+            (firstRt == RiskType::XCcyBasis && (secondRt == RiskType::IRCurve || secondRt == RiskType::Inflation))) {
+            // Between xccy basis and any yield or inflation in same currency
+            return xccyCorr_;
+        }
+        if ((firstRt == RiskType::IRCurve && secondRt == RiskType::Inflation) ||
+            (firstRt == RiskType::Inflation && secondRt == RiskType::IRCurve)) {
+            // Between any yield and inflation in same currency
+            return infCorr_;
+        }
+        if ((firstRt == RiskType::IRVol && secondRt == RiskType::InflationVol) ||
+            (firstRt == RiskType::InflationVol && secondRt == RiskType::IRVol)) {
+            // Between any yield volatility and inflation volatility in same currency
+            return infVolCorr_;
+        }
+    }
+
+    // Deal with IRCurve and IRVol correlations
+    if ((firstRt == RiskType::IRCurve && secondRt == RiskType::IRCurve) ||
+        (firstRt == RiskType::IRVol && secondRt == RiskType::IRVol)) {
+
+        // If the qualifiers, i.e. currencies, are the same
+        if (firstQualifier == secondQualifier) {
+            // Label2 level, i.e. sub-curve, correlations
+            if (firstLabel_2 != secondLabel_2) {
+                QL_REQUIRE(
+                    firstLabel_1 == "" && secondLabel_1 == "",
+                    "When asking for Label2 level correlations, "
+                        << "the Label1 level values should both contain the default parameter i.e. empty string");
+                QL_REQUIRE(firstRt != RiskType::IRVol, "There is no correlation at the Label2 level for Risk_IRVol");
+                return irSubCurveCorr_;
+            }
+
+            // Label1 level, i.e. tenor, correlations
+            RiskType rt = RiskType::IRCurve;
+            auto label12Key = makeKey("", firstLabel_1, secondLabel_1);
+            if (intraBucketCorrelation_.at(rt).find(label12Key) != intraBucketCorrelation_.at(rt).end())
+                return intraBucketCorrelation_.at(rt).at(label12Key);
+            else
+                QL_FAIL("Could not find correlation for risk type " << rt << " and key " << label12Key);
+        } else {
+            // If the qualifiers, i.e. currencies, are not the same
+            return irInterCurrencyCorr_;
+        }
+    }
+
+    // Deal with inflation volatility correlations
+    if (firstRt == RiskType::InflationVol && secondRt == RiskType::InflationVol) {
+        return 1.0;
+    }
+
     // Deal with FX correlations
     // TODO:
     // For FXVol, qualifier is a currency pair. Is it possible to get here
