QPR-11641 optimize sensi cube stream

pcaspers · jenkins · commit 15c42edfdea7 · 2023-04-13T14:00:53.000Z
diff --git a/OREAnalytics/orea/engine/sensitivitycubestream.cpp b/OREAnalytics/orea/engine/sensitivitycubestream.cpp
@@ -8,7 +8,7 @@
  ORE is free software: you can redistribute it and/or modify it
  under the terms of the Modified BSD License.  You should have received a
  copy of the license along with this program.
- The license is also available online at <http://opensourcerisk.org>
+ pr The license is also available online at <http://opensourcerisk.org>
 
  This program is distributed on the basis that it will form a useful
  contribution to risk analytics and model standardisation, but WITHOUT
@@ -31,107 +31,100 @@ namespace analytics {
 using crossPair = SensitivityCube::crossPair;
 
 SensitivityCubeStream::SensitivityCubeStream(const boost::shared_ptr<SensitivityCube>& cube, const string& currency)
-    : cube_(cube), currency_(currency), upRiskFactor_(cube_->upFactors().begin()),
-      downRiskFactor_(cube_->downFactors().begin()), itCrossPair_(cube_->crossFactors().begin()),
-      tradeIdx_(cube_->tradeIdx().begin()), canComputeGamma_(false) {
+    : cube_(cube), currency_(currency), canComputeGamma_(false) {
 
     // Set the value of canComputeGamma_ based on up and down risk factors.
     const auto& upFactors = cube_->upFactors();
     const auto& downFactors = cube_->downFactors();
     if (upFactors.size() == downFactors.size()) {
-        auto pred = [](decltype(*upFactors.left.begin()) a, pair<RiskFactorKey, SensitivityCube::FactorData> b) {
-            return a.first == b.first;
-        };
-        canComputeGamma_ = equal(upFactors.left.begin(), upFactors.left.end(), downFactors.begin(), pred);
+        canComputeGamma_ = equal(upFactors.begin(), upFactors.end(), downFactors.begin(),
+                                 [](const auto& a, const auto& b) { return a.first == b.first; });
     }
+
+    reset();
 }
 
 SensitivityRecord SensitivityCubeStream::next() {
 
-    SensitivityRecord sr;
+    while (tradeIdx_ != cube_->tradeIdx().end() && currentDeltaKey_ == currentDeltaKeys_.end() &&
+           currentCrossGammaKey_ == currentCrossGammaKeys_.end()) {
+        ++tradeIdx_;
+        updateForNewTrade();
+    }
 
-    const auto& upFactors = cube_->upFactors();
-    const auto& downFactors = cube_->downFactors();
+    if (tradeIdx_ == cube_->tradeIdx().end())
+        return SensitivityRecord();
 
-    // If exhausted deltas, gammas AND cross gammas, update to next trade and reset iterators
-    if (upRiskFactor_ == upFactors.end() && itCrossPair_ == cube_->crossFactors().end()) {
-        tradeIdx_++;
-        upRiskFactor_ = upFactors.begin();
-        downRiskFactor_ = downFactors.begin();
-        itCrossPair_ = cube_->crossFactors().begin();
+    SensitivityRecord sr;
+    Size tradeIdx = tradeIdx_->second;
+    sr.tradeId = tradeIdx_->first;
+    sr.isPar = false;
+    sr.currency = currency_;
+    sr.baseNpv = cube_->npv(tradeIdx);
+
+    if (currentDeltaKey_ != currentDeltaKeys_.end()) {
+        auto fd = cube_->upFactors().at(*currentDeltaKey_);
+        sr.key_1 = *currentDeltaKey_;
+        sr.desc_1 = fd.factorDesc;
+        sr.shift_1 = fd.shiftSize;
+        sr.delta = cube_->delta(tradeIdx_->first, *currentDeltaKey_);
+        if (canComputeGamma_)
+            sr.gamma = cube_->gamma(tradeIdx_->first, *currentDeltaKey_);
+        else
+            sr.gamma = Null<Real>();
+        ++currentDeltaKey_;
+    } else if (currentCrossGammaKey_ != currentCrossGammaKeys_.end()) {
+        auto fd = cube_->crossFactors().at(*currentCrossGammaKey_);
+        sr.key_1 = currentCrossGammaKey_->first;
+        sr.desc_1 = std::get<0>(fd).factorDesc;
+        sr.shift_1 = std::get<0>(fd).shiftSize;
+        sr.key_2 = currentCrossGammaKey_->second;
+        sr.desc_2 = std::get<1>(fd).factorDesc;
+        sr.shift_2 = std::get<1>(fd).shiftSize;
+        sr.gamma = cube_->crossGamma(tradeIdx_->first, *currentCrossGammaKey_);
+        ++currentCrossGammaKey_;
     }
 
-    // Give back next record if we have a valid trade index
-    if (tradeIdx_ != cube_->tradeIdx().end()) {
-        Size tradeIdx = tradeIdx_->second;
-        sr.tradeId = tradeIdx_->first;
-        sr.isPar = false;
-        sr.currency = currency_;
-        sr.baseNpv = cube_->npv(tradeIdx);
-
-        // Are there more deltas and gammas for current trade ID
-        if (upRiskFactor_ != upFactors.end()) {
-            Size usrx = upRiskFactor_->right.index;
-            sr.key_1 = upRiskFactor_->left;
-            sr.desc_1 = upRiskFactor_->right.factorDesc;
-            sr.shift_1 = upRiskFactor_->right.shiftSize;
-
-            if (!cube_->twoSidedDelta(sr.key_1.keytype)) {
-                sr.delta = cube_->delta(tradeIdx, usrx);
-            } else {
-                Size downIdx = downFactors.at(sr.key_1).index;
-                sr.delta = cube_->delta(tradeIdx, usrx, downIdx);
-            }
-
-            if (canComputeGamma_ && downRiskFactor_ != downFactors.end()) {
-                Size dsrx = downRiskFactor_->second.index;
-                sr.gamma = cube_->gamma(tradeIdx, usrx, dsrx);
-                downRiskFactor_++;
-            } else {
-                sr.gamma = Null<Real>(); // marks na result
-            }
+    TLOG("Next record is: " << sr);
+    return sr;
+}
 
-            upRiskFactor_++;
+void SensitivityCubeStream::updateForNewTrade() {
+    currentDeltaKeys_.clear();
+    currentCrossGammaKeys_.clear();
 
-            TLOG("Next record is: " << sr);
-            return sr;
-        }
+    if (tradeIdx_ != cube_->tradeIdx().end()) {
 
-        // Are there more cross pairs for current trade ID
-        if (itCrossPair_ != cube_->crossFactors().end()) {
-            sr.key_1 = itCrossPair_->first.first;
-            sr.desc_1 = std::get<0>(itCrossPair_->second).factorDesc;
-            sr.shift_1 = std::get<0>(itCrossPair_->second).shiftSize;
+        // add delta keys
 
-            sr.key_2 = itCrossPair_->first.second;
-            sr.desc_2 = std::get<1>(itCrossPair_->second).factorDesc;
-            sr.shift_2 = std::get<1>(itCrossPair_->second).shiftSize;
+        for (auto const& [idx, _] : cube_->npvCube()->getTradeNPVs(tradeIdx_->second)) {
+            if (auto k = cube_->upDownFactor(idx); k.keytype != RiskFactorKey::KeyType::None)
+                currentDeltaKeys_.insert(k);
+        }
 
-            Size id_1, id_2, id_x;
-            id_1 = std::get<0>(itCrossPair_->second).index;
-            id_2 = std::get<1>(itCrossPair_->second).index;
-            id_x = std::get<2>(itCrossPair_->second);
+        // add cross gamma keys
 
-            sr.gamma = cube_->crossGamma(tradeIdx, id_1, id_2, id_x);
+        for (auto const& [crossPair, data] : cube_->crossFactors()) {
+            if (!close_enough(cube_->crossGamma(tradeIdx_->second, std::get<0>(data).index, std::get<1>(data).index,
+                                                std::get<2>(data)),
+                              0.0)) {
+                currentCrossGammaKeys_.insert(crossPair);
 
-            itCrossPair_++;
+                // make sure, delta keys contain both cross keys, that's a guarantee of the SensitivityCubeStream
 
-            TLOG("Next record is: " << sr);
-            return sr;
+                currentDeltaKeys_.insert(crossPair.first);
+                currentDeltaKeys_.insert(crossPair.second);
+            }
         }
     }
 
-    // If we get to here, no more cube sensitivities to process so return empty record
-    TLOG("Next record is: " << sr);
-    return sr;
+    currentDeltaKey_ = currentDeltaKeys_.begin();
+    currentCrossGammaKey_ = currentCrossGammaKeys_.begin();
 }
 
 void SensitivityCubeStream::reset() {
-    // Reset indices and iterators
     tradeIdx_ = cube_->tradeIdx().begin();
-    upRiskFactor_ = cube_->upFactors().begin();
-    downRiskFactor_ = cube_->downFactors().begin();
-    itCrossPair_ = cube_->crossFactors().begin();
+    updateForNewTrade();
 }
 
 } // namespace analytics
diff --git a/OREAnalytics/orea/engine/sensitivitycubestream.hpp b/OREAnalytics/orea/engine/sensitivitycubestream.hpp
@@ -51,20 +51,23 @@ class SensitivityCubeStream : public SensitivityStream {
     void reset() override;
 
 private:
+    void updateForNewTrade();
+
     //! Handle on the SensitivityCube
     boost::shared_ptr<SensitivityCube> cube_;
     //! Currency of the sensitivities in the SensitivityCube
     std::string currency_;
 
-    //! Iterator to risk factor keys in the cube
-    boost::bimap<RiskFactorKey, ore::analytics::SensitivityCube::FactorData>::const_iterator upRiskFactor_;
-    std::map<RiskFactorKey, ore::analytics::SensitivityCube::FactorData>::const_iterator downRiskFactor_;
-    //! Iterator to cross factors in the cube
-    std::map<ore::analytics::SensitivityCube::crossPair,
-             std::tuple<ore::analytics::SensitivityCube::FactorData, ore::analytics::SensitivityCube::FactorData,
-                        QuantLib::Size>>::const_iterator itCrossPair_;
-    //! Index of current trade Id in the cube
+    //! Current delta risk factor keys to process and iterators
+    std::set<RiskFactorKey> currentDeltaKeys_;
+    std::set<std::pair<RiskFactorKey,RiskFactorKey>> currentCrossGammaKeys_;
+
+    std::set<RiskFactorKey>::const_iterator currentDeltaKey_;
+    std::set<std::pair<RiskFactorKey,RiskFactorKey>>::const_iterator currentCrossGammaKey_;
+
+    //! Current trade iterator
     std::map<std::string, QuantLib::Size>::const_iterator tradeIdx_;
+
     //! Can only compute gamma if the up and down risk factors align
     bool canComputeGamma_;
 };
