QPR-13799 Correlation: Allow portfolio to be different from scenario

Author: sebastien.bouvard

OREAnalytics/orea/app/analytics/correlationanalytic.cpp

@@ -114,7 +114,8 @@ void CorrelationAnalyticImpl::setCorrelationReport(const QuantLib::ext::shared_p
                                                                 analytic()->configurations().simMarketParams);
 
     correlationReport_ = ext::make_shared<CorrelationReport>(inputs_->scenarioReader(),
-            inputs_->correlationMethod(), benchmarkVarPeriod, scenarios, shiftCalculator);
+            inputs_->correlationMethod(), benchmarkVarPeriod, scenarios, shiftCalculator,
+            analytic()->configurations().sensiScenarioData);
 }
 
 } //namespace analytics

OREAnalytics/orea/engine/correlationreport.cpp

@@ -16,6 +16,7 @@
  FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
 */
 #include <orea/engine/correlationreport.hpp>
+#include <orea/scenario/sensitivityscenariodata.hpp>
 #include <ored/utilities/to_string.hpp>
 #include <qle/math/deltagammavar.hpp>
 #include <ored/utilities/correlationmatrix.hpp>
@@ -35,6 +36,26 @@ void CorrelationReport::calculate(const ext::shared_ptr<Report>& report) {
     ext::shared_ptr<Scenario> sc = hisScenGen_->next(hisScenGen_->baseScenario()->asof());
     std::vector<RiskFactorKey> deltaKeys = sc->keys();
 
+    // Filter deltaKeys to the union with risk factors generated from the portfolio based on (KeyType, Name)
+    // i.e., keep only those deltaKeys present in ptfRiskFactors ignoring index
+    // populateSensiShifts iterate over the scenario and deltaKeys, if mismatch with the sensiScenarioData shift
+    // it throws an error.
+    auto ptfRiskFactors = sensiScenarioData_->getPortfolioRiskFactors();
+    if(ptfRiskFactors.size()>0){
+        std::set<std::pair<RiskFactorKey::KeyType, std::string>> ptfKeyNameSet;
+        for (auto& k : ptfRiskFactors) {
+            ptfKeyNameSet.emplace(k.keytype, k.name);
+        }
+        std::vector<RiskFactorKey> filteredKeys;
+        filteredKeys.reserve(deltaKeys.size());
+        for (auto& k : deltaKeys) {
+            if (ptfKeyNameSet.count(std::make_pair(k.keytype, k.name)) > 0) {
+                filteredKeys.push_back(k);
+            }
+        }
+        deltaKeys.swap(filteredKeys);
+    }
+
     ext::shared_ptr<NPVCube>cube;
     ext::shared_ptr<CovarianceCalculator> covCalculator;
     covCalculator = ext::make_shared<CovarianceCalculator>(covariancePeriod());

OREAnalytics/orea/engine/correlationreport.hpp

@@ -39,9 +39,10 @@ class CorrelationReport{
                       const std::string& correlationMethod,
                       QuantLib::ext::optional<ore::data::TimePeriod> period,
                       const QuantLib::ext::shared_ptr<HistoricalScenarioGenerator>& hisScenGen = nullptr,
-                      const QuantLib::ext::shared_ptr<ScenarioShiftCalculator>& shiftCalc = nullptr)
+                      const QuantLib::ext::shared_ptr<ScenarioShiftCalculator>& shiftCalc = nullptr,
+                      QuantLib::ext::shared_ptr<ore::analytics::SensitivityScenarioData> sensiScenarioData = nullptr)
         : scenario_(scenario), correlationMethod_(correlationMethod), period_(period), hisScenGen_(hisScenGen),
-          shiftCalc_(shiftCalc) {
+          shiftCalc_(shiftCalc), sensiScenarioData_(sensiScenarioData) {
     }
 
     void writeReports(const QuantLib::ext::shared_ptr<Report>& report);
@@ -59,6 +60,7 @@ class CorrelationReport{
     QuantLib::Matrix correlationMatrix_;
     std::map<std::pair<RiskFactorKey, RiskFactorKey>, Real> correlationPairs_;
     std::vector<QuantLib::ext::shared_ptr<PNLCalculator>> pnlCalculators_;
+    QuantLib::ext::shared_ptr<ore::analytics::SensitivityScenarioData> sensiScenarioData_;
 
     ore::data::TimePeriod covariancePeriod() const { return period_.value(); } 
     std::vector<ore::data::TimePeriod> timePeriods() { return {period_.value()}; }

OREAnalytics/orea/scenario/sensitivityscenariodata.hpp

@@ -304,6 +304,7 @@ class SensitivityScenarioData : public XMLSerializable {
     void setComputeGamma(const bool b) { computeGamma_ = b; }
     void setUseSpreadedTermStructures(const bool b) { useSpreadedTermStructures_ = b; }
     void setParConversionExcludeFixings(const std::string b) { parConversionExcludeFixings_ = b; }
+    void setPortfolioRiskFactors(const std::vector<RiskFactorKey> b) { portfolioRiskFactors_ = b;}
 
     //@}
 
@@ -322,6 +323,7 @@ class SensitivityScenarioData : public XMLSerializable {
     //! Utilities
     //@{
     string getIndexCurrency(string indexName);
+    std::vector<RiskFactorKey> getPortfolioRiskFactors(){return portfolioRiskFactors_;}
     //@}
 
 protected:
@@ -369,6 +371,7 @@ class SensitivityScenarioData : public XMLSerializable {
     set<ore::analytics::RiskFactorKey::KeyType> parConversionExcludes_;
     std::string parConversionExcludeFixings_;
     ore::data::ParConversionMatrixRegularisation parConversionMatrixRegularisation_;
+    std::vector<RiskFactorKey> portfolioRiskFactors_;
 
 private:
     void parDataFromXML(XMLNode* child, CurveShiftParData& data);