QPR-13719 add cube npv overlay

Author: pcaspers

OREAnalytics/orea/app/analytics/pricinganalytic.cpp

@@ -33,6 +33,8 @@ namespace analytics {
  * PRICING Analytic: NPV, CASHFLOW, CASHFLOWNPV, SENSITIVITY, STRESS
  *******************************************************************/
 
+void PricingAnalyticImpl::overwriteResultCurrency(const std::string& ccy) { overwriteResultCurrency_ = ccy; }
+
 void PricingAnalyticImpl::setUpConfigurations() {    
     if (find(begin(analytic()->analyticTypes()), end(analytic()->analyticTypes()), "SENSITIVITY") !=
         end(analytic()->analyticTypes())) {
@@ -83,8 +85,12 @@ void PricingAnalyticImpl::runAnalytic(
         if (runTypes.find(type) == runTypes.end())
             continue;
 
-        std::string effectiveResultCurrency =
-            inputs_->resultCurrency().empty() ? inputs_->baseCurrency() : inputs_->resultCurrency();
+        std::string effectiveResultCurrency = inputs_->baseCurrency();
+        if (inputs_->resultCurrency().empty())
+            effectiveResultCurrency = inputs_->resultCurrency();
+        if (overwriteResultCurrency_) {
+            effectiveResultCurrency = *overwriteResultCurrency_;
+        }
         auto marketConfig = inputs_->marketConfig("pricing");
         if (type == "NPV") {
             CONSOLEW("Pricing: NPV Report");

OREAnalytics/orea/app/analytics/pricinganalytic.hpp

@@ -52,13 +52,16 @@ class PricingAnalyticImpl : public Analytic::Impl {
         offsetSimMarketParams_ = offsetSimMarketParams;
     }
 
+    void overwriteResultCurrency(const std::string& ccy);
+
 private:
     QuantLib::ext::shared_ptr<SensitivityAnalysis> sensiAnalysis_;
     QuantLib::ext::shared_ptr<ParSensitivityAnalysis> parAnalysis_;
 
 protected:
     QuantLib::ext::shared_ptr<Scenario> offsetScenario_;
     QuantLib::ext::shared_ptr<ScenarioSimMarketParameters> offsetSimMarketParams_;
+    std::optional<std::string> overwriteResultCurrency_;
 };
 
 static const std::set<std::string> pricingAnalyticSubAnalytics {"NPV", "CASHFLOW", "CASHFLOWNPV", "SENSITIVITY"};

OREAnalytics/orea/app/analytics/xvaanalytic.cpp

@@ -27,6 +27,7 @@
 #include <orea/app/reportwriter.hpp>
 #include <orea/app/structuredanalyticserror.hpp>
 #include <orea/app/structuredanalyticswarning.hpp>
+#include <orea/cube/overlaynpvcube.hpp>
 #include <orea/cube/jointnpvcube.hpp>
 #include <orea/cube/npvcube.hpp>
 #include <orea/cube/sparsenpvcube.hpp>
@@ -93,6 +94,13 @@ void XvaAnalyticImpl::buildDependencies() {
             if (correlationAnalytic.second)
                 addDependentAnalytic(corrLookupKey, correlationAnalytic.second);
     }
+    if (inputs_->cubeNpvOverlay()) {
+        if (auto pricingAnalytic =
+                AnalyticFactory::instance().build("PRICING", inputs_, analytic()->analyticsManager(), false);
+            pricingAnalytic.second) {
+            addDependentAnalytic("PRICING", pricingAnalytic.second);
+        }
+    }
 }
 
 void XvaAnalyticImpl::feedCorrelationToCAM(const std::map<std::pair<RiskFactorKey, RiskFactorKey>, Real>& corrData){
@@ -969,6 +977,22 @@ void XvaAnalyticImpl::runAnalytic(const QuantLib::ext::shared_ptr<ore::data::InM
     Settings::instance().includeReferenceDateEvents() = localIncRefDateEvents;
     LOG("Simulation IncludeReferenceDateEvents is set to " << (localIncRefDateEvents ? "true" : "false"));
 
+    std::map<std::string, double> cubeNpvOverlay;
+    if (inputs_->cubeNpvOverlay()) {
+        auto pricingAnalytic = dependentAnalytic("PRICING");
+        static_cast<PricingAnalyticImpl*>(pricingAnalytic->impl().get())
+            ->overwriteResultCurrency(analytic()->configurations().simMarketParams->baseCcy());
+        pricingAnalytic->runAnalytic(loader,{"NPV"});
+        auto npvReport = pricingAnalytic->reports().at("NPV").at("npv");
+        // FIXME ensure base currency matches sim market base ccy
+        std::size_t colTradeId = npvReport->columnPosition("TradeId");
+        std::size_t colNpvBase = npvReport->columnPosition("NPV(Base)");
+        for (Size r = 0; r < npvReport->rows(); ++r) {
+            cubeNpvOverlay[boost::get<std::string>(npvReport->data(colTradeId, r))] =
+                boost::get<double>(npvReport->data(colNpvBase, r));
+        }
+    }
+
     if(inputs_->generateCorrelations()){
         auto corrAnalytic = dependentAnalytic(corrLookupKey);
         corrAnalytic->runAnalytic(loader,{"CORRELATION"});
@@ -1108,11 +1132,19 @@ void XvaAnalyticImpl::runAnalytic(const QuantLib::ext::shared_ptr<ore::data::InM
             LOG("We have generated an AMC cube only");
             cube_ = amcCube_;
         } else {
-            WLOG("We have generated a classic cube only");
+            LOG("We have generated a classic cube only");
         }
 
         LOG("NPV cube generation completed");
 
+        /************************************************************
+         * Apply correction pricing t0 npv - sim t0 npv if requested
+         ************************************************************/
+
+        if (!cubeNpvOverlay.empty()) {
+            cube_ = QuantLib::ext::make_shared<OverlayNPVCube>(cube_, cubeNpvOverlay);
+        }
+
         /***********************************************************************
          * We may have two non-empty portfolios to be merged for post processing
          ***********************************************************************/

OREAnalytics/orea/app/inputparameters.hpp

@@ -332,6 +332,7 @@ class InputParameters {
     void setStoreSurvivalProbabilities(bool b) { storeSurvivalProbabilities_ = b; }
     void setWriteCube(bool b) { writeCube_ = b; }
     void setWriteScenarios(bool b) { writeScenarios_ = b; }
+    void setCubeNpvOverlay(bool b) { cubeNpvOverlay_ = b; }
     void setExposureSimMarketParams(const std::string& xml);
     void setExposureSimMarketParamsFromFile(const std::string& fileName);
     void setScenarioGeneratorData(const std::string& xml);
@@ -823,6 +824,7 @@ class InputParameters {
     bool writeCube() const { return writeCube_; }
     bool writeScenarios() const { return writeScenarios_; }
     bool generateCorrelations() const {return generateCorrelations_;}
+    bool cubeNpvOverlay() const { return cubeNpvOverlay_; }
     const QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarketParameters>& exposureSimMarketParams() const { return exposureSimMarketParams_; }
     const QuantLib::ext::shared_ptr<ScenarioGeneratorData> scenarioGeneratorData() const { return scenarioGeneratorData_; }
     const QuantLib::ext::shared_ptr<CrossAssetModelData>& crossAssetModelData() const { return crossAssetModelData_; }
@@ -1316,6 +1318,7 @@ class InputParameters {
     bool writeCube_ = false;
     bool writeScenarios_ = false;
     bool generateCorrelations_ = false;
+    bool cubeNpvOverlay_ = false;
     QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarketParameters> exposureSimMarketParams_;
     QuantLib::ext::shared_ptr<ScenarioGeneratorData> scenarioGeneratorData_;
     QuantLib::ext::shared_ptr<CrossAssetModelData> crossAssetModelData_;

OREAnalytics/orea/app/oreapp.cpp

@@ -2103,6 +2103,10 @@ void OREAppInputParameters::loadParameters() {
         if (tmp != "")
             setWriteCube(true);
 
+        tmp = params_->get("simulation", "cubeNpvOverlay", false);
+        if (tmp != "")
+            setCubeNpvOverlay(parseBool(tmp));
+
         tmp = params_->get("simulation", "scenariodump", false);
         if (tmp != "")
             setWriteScenarios(true);

OREAnalytics/orea/orea.hpp

@@ -83,6 +83,7 @@
 #include <orea/cube/jointnpvsensicube.hpp>
 #include <orea/cube/npvcube.hpp>
 #include <orea/cube/npvsensicube.hpp>
+#include <orea/cube/overlaynpvcube.hpp>
 #include <orea/cube/sensicube.hpp>
 #include <orea/cube/sensitivitycube.hpp>
 #include <orea/cube/sparsenpvcube.hpp>