Merge branch 'feature/QPR-13719' into 'master'

Resolve QPR-13719 add exposure cube npv overlay

Closes QPR-13719

See merge request qs/oreplus!3184

Author: damienbarker

Docs/UserGuide/parameterisation/ore.tex

@@ -348,7 +348,7 @@ \subsubsection{Simulation and Model Calibration}
     <Parameter name="cptyCubeFile">cptyCube.csv.gz</Parameter>
     <Parameter name="storeSurvivalProbabilities">Y</Parameter>
     <Parameter name="storeCreditStateNPVs">8</Parameter>
-    <Parameter name="salvageCorrelationMatrix">true</Parameter>
+    <Parameter name="cubeNpvOverlay">true</Parameter>
   </Analytic>
 </Analytics>
 \end{minted}
@@ -369,6 +369,8 @@ \subsubsection{Simulation and Model Calibration}
 cube for post processing in the context of some Dynamic Initial Margin and Variation Margin models. And finally, the
 key `store survival probabilities' (Y or N) controls whether survival probabilities on simulation dates are stored in the
 cube for post processing in the context of Dynamic Credit XVA calculation.
+Key 'cubeNpvOverlay' is optional and defaults to false. If true, all raw npv cube entries are corrected by the
+difference of the T0 npv from the pricing analytic and the T0 npv from the simulation npv.
 
 \medskip
 To use  AMC simulation the simulation setup needs the additional elements shown in \ref{lst:ore_amc_simulation}

Docs/UserGuide/parameterisation/simulation.tex

@@ -121,6 +121,7 @@ \subsubsection{Model}\label{sec:sim_model}
   <BootstrapTolerance>0.0001</BootstrapTolerance>
   <Measure>LGM</Measure><!-- Choices: LGM, BA -->
   <Discretization>Exact</Discretization>
+  <SalvagingAlgorithm>Spectral</SalvagingAlgorithm>
   <!-- ... -->
 </CrossAssetModel>
 \end{minted}
@@ -139,6 +140,8 @@ \subsubsection{Model}\label{sec:sim_model}
 testing purposes or if more sophisticated component models are used). If {\em Euler} is used, you should consider
 setting TimeStepsPerYear (see above) to a large enough value.
 
+The SalvagingAlgorithm tag specifies the preprocessing of the input correlation matrix (None, Spectral, Hypersphere, LowerDiagonal, Higham). Optional, defaults to None.
+
 \medskip
 
 Each interest rate model is specified by a block as follows

OREAnalytics/orea/CMakeLists.txt

@@ -71,6 +71,7 @@ cube/inmemorycubeopt.cpp
 cube/jaggedcube.cpp
 cube/jointnpvcube.cpp
 cube/jointnpvsensicube.cpp
+cube/overlaynpvcube.cpp
 cube/sensicube.cpp
 cube/sensitivitycube.cpp
 cube/sparsenpvcube.cpp
@@ -292,6 +293,7 @@ cube/jointnpvcube.hpp
 cube/jointnpvsensicube.hpp
 cube/npvcube.hpp
 cube/npvsensicube.hpp
+cube/overlaynpvcube.hpp
 cube/sensicube.hpp
 cube/sensitivitycube.hpp
 cube/sparsenpvcube.hpp

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,21 @@ 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");
+        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 +1131,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/cube/overlaynpvcube.cpp

@@ -0,0 +1,78 @@
+/*
+ Copyright (C) 2026 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ 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>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file orea/cube/overlaynpvcube.hpp
+    \brief npv cube corrected by difference pricing t0 npv and sim t0 npv
+    \ingroup cube
+*/
+
+#include <orea/cube/overlaynpvcube.hpp>
+
+namespace ore {
+namespace analytics {
+
+OverlayNPVCube::OverlayNPVCube(const QuantLib::ext::shared_ptr<NPVCube>& cube,
+                               const std::map<std::string, double>& pricingNpvs)
+    : cube_(cube) {
+    pricingNpvs_.resize(cube_->numIds());
+    for (auto const& [id, index] : cube_->idsAndIndexes()) {
+        QL_REQUIRE(index < pricingNpvs_.size(), "OverlayNPVCube(): numIds (" << cube_->numIds()
+                                                                             << ") does not cover index (" << index
+                                                                             << ") for id " << id);
+        if (auto p = pricingNpvs.find(id); p != pricingNpvs.end())
+            pricingNpvs_[index] = p->second;
+        else {
+            QL_FAIL("OverlayNPVCube(): no pricingNpv given for id " << id);
+        }
+    }
+}
+
+Size OverlayNPVCube::numIds() const { return cube_->numIds(); }
+
+Size OverlayNPVCube::numDates() const { return cube_->numDates(); }
+
+Size OverlayNPVCube::samples() const { return cube_->samples(); }
+
+Size OverlayNPVCube::depth() const { return cube_->depth(); }
+
+const std::map<std::string, Size>& OverlayNPVCube::idsAndIndexes() const { return cube_->idsAndIndexes(); }
+
+const std::vector<QuantLib::Date>& OverlayNPVCube::dates() const { return cube_->dates(); }
+
+QuantLib::Date OverlayNPVCube::asof() const { return cube_->asof(); }
+
+Real OverlayNPVCube::getT0(Size id, Size depth) const { return cube_->getT0(id, depth) + correction(id, depth); }
+
+void OverlayNPVCube::setT0(Real value, Size id, Size depth) { cube_->setT0(value - correction(id, depth), id, depth); }
+
+Real OverlayNPVCube::get(Size id, Size date, Size sample, Size depth) const {
+    return cube_->get(id, date, sample, depth) + correction(id, depth);
+}
+
+void OverlayNPVCube::set(Real value, Size id, Size date, Size sample, Size depth) {
+    cube_->set(value - correction(id, depth), id, date, sample, depth);
+}
+
+bool OverlayNPVCube::usesDoublePrecision() const { return cube_->usesDoublePrecision(); }
+
+double OverlayNPVCube::correction(Size id, Size depth) const {
+    return depth == 0 ? pricingNpvs_[id] - cube_->getT0(id, depth) : 0.0;
+}
+
+} // namespace analytics
+} // namespace ore

OREAnalytics/orea/cube/overlaynpvcube.hpp

@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2026 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ 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>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file orea/cube/overlaynpvcube.hpp
+    \brief npv cube corrected by difference pricing t0 npv and sim t0 npv
+    \ingroup cube
+*/
+
+#pragma once
+
+#include <orea/cube/npvcube.hpp>
+
+namespace ore {
+namespace analytics {
+
+class OverlayNPVCube : public NPVCube {
+public:
+    OverlayNPVCube(const QuantLib::ext::shared_ptr<NPVCube>& cube, const std::map<std::string, double>& pricingNpvs);
+    Size numIds() const override;
+    Size numDates() const override;
+    Size samples() const override;
+    Size depth() const override;
+    const std::map<std::string, Size>& idsAndIndexes() const override;
+    const std::vector<QuantLib::Date>& dates() const override;
+    QuantLib::Date asof() const override;
+    Real getT0(Size id, Size depth = 0) const override;
+    void setT0(Real value, Size id, Size depth = 0) override;
+    Real get(Size id, Size date, Size sample, Size depth = 0) const override;
+    void set(Real value, Size id, Size date, Size sample, Size depth = 0) override;
+    bool usesDoublePrecision() const override;
+
+private:
+    double correction(Size id, Size depth) const;
+
+    QuantLib::ext::shared_ptr<NPVCube> cube_;
+    std::vector<double> pricingNpvs_;
+};
+
+} // namespace analytics
+} // namespace ore