QPR-13799 Supress Error Message

Author: sebastien.bouvard

OREAnalytics/orea/app/analytics/correlationanalytic.cpp

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

OREAnalytics/orea/engine/correlationreport.cpp

@@ -16,7 +16,6 @@
  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>
@@ -40,28 +39,14 @@ void CorrelationReport::calculate(const ext::shared_ptr<Report>& report) {
     // 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);
-    }
+    bool supressError = true;
 
     ext::shared_ptr<NPVCube>cube;
     ext::shared_ptr<CovarianceCalculator> covCalculator;
     covCalculator = ext::make_shared<CovarianceCalculator>(covariancePeriod());
 
     sensiPnlCalculator_ = ext::make_shared<HistoricalSensiPnlCalculator>(hisScenGen_, nullptr);
-    sensiPnlCalculator_->populateSensiShifts(cube, deltaKeys, shiftCalc_);
+    sensiPnlCalculator_->populateSensiShifts(cube, deltaKeys, shiftCalc_, supressError);
     sensiPnlCalculator_->calculateSensiPnl({}, deltaKeys, cube, pnlCalculators_, covCalculator, {},
                                            false, false, false);
 

OREAnalytics/orea/engine/correlationreport.hpp

@@ -39,10 +39,9 @@ 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,
-                      QuantLib::ext::shared_ptr<ore::analytics::SensitivityScenarioData> sensiScenarioData = nullptr)
+                      const QuantLib::ext::shared_ptr<ScenarioShiftCalculator>& shiftCalc = nullptr)
         : scenario_(scenario), correlationMethod_(correlationMethod), period_(period), hisScenGen_(hisScenGen),
-          shiftCalc_(shiftCalc), sensiScenarioData_(sensiScenarioData) {
+          shiftCalc_(shiftCalc) {
     }
 
     void writeReports(const QuantLib::ext::shared_ptr<Report>& report);
@@ -60,7 +59,6 @@ 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/engine/historicalsensipnlcalculator.cpp

@@ -173,7 +173,7 @@ void PNLCalculator::populateRiskFactorTradePNLs(const RiskFactorTradePnLStore& a
 }
 
 void HistoricalSensiPnlCalculator::populateSensiShifts(QuantLib::ext::shared_ptr<NPVCube>& cube, const vector<RiskFactorKey>& keys,
-    ext::shared_ptr<ScenarioShiftCalculator> shiftCalculator) {
+    ext::shared_ptr<ScenarioShiftCalculator> shiftCalculator, const bool& supressError) {
 
     hisScenGen_->reset();
     QuantLib::ext::shared_ptr<Scenario> baseScenario = hisScenGen_->baseScenario();
@@ -200,11 +200,13 @@ void HistoricalSensiPnlCalculator::populateSensiShifts(QuantLib::ext::shared_ptr
                 Real shift = shiftCalculator->shift(key, *baseScenario, *scenario, isPar);
                 cube->set(shift, j, 0, i);
             } catch (const std::exception& e) {
-                StructuredAnalyticsErrorMessage(
+                if(!supressError){
+                    StructuredAnalyticsErrorMessage(
                     "HistocialSensiPnlCalculator",
                     "Shift calculation failed. Check consistency of simulation and sensi config.",
                     "Error retrieving sensi key '" + ore::data::to_string(key) + "' from ssm scenario: '" + e.what())
                     .log();
+                }
             }
             j++;
         }

OREAnalytics/orea/engine/historicalsensipnlcalculator.hpp

@@ -118,7 +118,8 @@ class HistoricalSensiPnlCalculator {
         : hisScenGen_(hisScenGen), sensitivityStream_(ss) {}
 
     void populateSensiShifts(QuantLib::ext::shared_ptr<NPVCube>& cube, const vector<RiskFactorKey>& keys,
-                             QuantLib::ext::shared_ptr<ScenarioShiftCalculator> shiftCalculator);
+                             QuantLib::ext::shared_ptr<ScenarioShiftCalculator> shiftCalculator,
+                             const bool& supressError = false);
 
     void calculateSensiPnl(const std::set<SensitivityRecord>& srs,
         const std::vector<RiskFactorKey>& rfKeys,

OREAnalytics/orea/scenario/sensitivityscenariodata.hpp

@@ -304,7 +304,6 @@ 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;}
 
     //@}
 
@@ -323,7 +322,6 @@ class SensitivityScenarioData : public XMLSerializable {
     //! Utilities
     //@{
     string getIndexCurrency(string indexName);
-    std::vector<RiskFactorKey> getPortfolioRiskFactors(){return portfolioRiskFactors_;}
     //@}
 
 protected:
@@ -371,7 +369,6 @@ 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);