QPR-12028 PoC XVA Sensis AAD

Author: pcaspers

OREData/ored/CMakeLists.txt

@@ -313,6 +313,8 @@ scripting/models/blackscholescg.cpp
 scripting/models/blackscholescgbase.cpp
 scripting/models/fdblackscholesbase.cpp
 scripting/models/gaussiancam.cpp
+scripting/models/gaussiancamcg.cpp
+scripting/models/lgmcg.cpp
 scripting/models/localvol.cpp
 scripting/models/modelcgimpl.cpp
 scripting/models/modelimpl.cpp
@@ -684,13 +686,16 @@ scripting/engines/scriptedinstrumentpricingengine.hpp
 scripting/engines/scriptedinstrumentpricingenginecg.hpp
 scripting/grammar.hpp
 scripting/models/amcmodel.hpp
+scripting/models/amcmodelcg.hpp
 scripting/models/blackscholes.hpp
 scripting/models/blackscholesbase.hpp
 scripting/models/blackscholescg.hpp
 scripting/models/blackscholescgbase.hpp
 scripting/models/dummymodel.hpp
 scripting/models/fdblackscholesbase.hpp
 scripting/models/gaussiancam.hpp
+scripting/models/gaussiancamcg.hpp
+scripting/models/lgmcg.hpp
 scripting/models/localvol.hpp
 scripting/models/model.hpp
 scripting/models/modelcg.hpp

OREData/ored/ored.hpp

@@ -334,13 +334,16 @@
 #include <ored/scripting/engines/scriptedinstrumentpricingenginecg.hpp>
 #include <ored/scripting/grammar.hpp>
 #include <ored/scripting/models/amcmodel.hpp>
+#include <ored/scripting/models/amcmodelcg.hpp>
 #include <ored/scripting/models/blackscholes.hpp>
 #include <ored/scripting/models/blackscholesbase.hpp>
 #include <ored/scripting/models/blackscholescg.hpp>
 #include <ored/scripting/models/blackscholescgbase.hpp>
 #include <ored/scripting/models/dummymodel.hpp>
 #include <ored/scripting/models/fdblackscholesbase.hpp>
 #include <ored/scripting/models/gaussiancam.hpp>
+#include <ored/scripting/models/gaussiancamcg.hpp>
+#include <ored/scripting/models/lgmcg.hpp>
 #include <ored/scripting/models/localvol.hpp>
 #include <ored/scripting/models/model.hpp>
 #include <ored/scripting/models/modelcg.hpp>

OREData/ored/portfolio/builders/scriptedtrade.cpp

@@ -21,6 +21,7 @@
 #include <ored/scripting/models/blackscholescg.hpp>
 #include <ored/scripting/models/fdblackscholesbase.hpp>
 #include <ored/scripting/models/gaussiancam.hpp>
+#include <ored/scripting/models/gaussiancamcg.hpp>
 #include <ored/scripting/models/localvol.hpp>
 #include <ored/scripting/engines/scriptedinstrumentpricingengine.hpp>
 #include <ored/scripting/engines/scriptedinstrumentpricingenginecg.hpp>
@@ -1278,7 +1279,7 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
     std::vector<boost::shared_ptr<EqBsData>> eqConfigs;
     std::vector<boost::shared_ptr<CommoditySchwartzData>> comConfigs;
     // TODO: populate comConfigs
-    
+
     // calibration expiries and terms for IR, INF, FX, EQ parametrisations (this will only work for a fixed reference
     // date, due to the way the cam builder and nested builders work, see ticket #940)
     Date referenceDate = modelCurves_.front()->referenceDate();
@@ -1473,19 +1474,30 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
 
     std::string configurationInCcy = configuration(MarketContext::irCalibration);
     std::string configurationXois = configuration(MarketContext::pricing);
+    auto discretization = useCg_ ? CrossAssetModel::Discretization::Euler : CrossAssetModel::Discretization::Exact;
     auto camBuilder = boost::make_shared<CrossAssetModelBuilder>(
         market_,
         boost::make_shared<CrossAssetModelData>(irConfigs, fxConfigs, eqConfigs, infConfigs, crLgmConfigs, crCirConfigs,
-                                                comConfigs, 0, camCorrelations, bootstrapTolerance_),
+                                                comConfigs, 0, camCorrelations, bootstrapTolerance_, "LGM",
+                                                discretization),
         configurationInCcy, configurationXois, configurationXois, configurationInCcy, configurationInCcy,
         configurationXois, !calibrate_ || zeroVolatility_, continueOnCalibrationError_, referenceCalibrationGrid_,
         SalvagingAlgorithm::Spectral, id);
 
-    // TODO hardcode timeStepsPerYear to 0 and exact discretisation (we might want Euler for AD...)
-    model_ = boost::make_shared<GaussianCam>(camBuilder->model(), modelSize_, modelCcys_, modelCurves_, modelFxSpots_,
-                                             modelIrIndices_, modelInfIndices_, modelIndices_, modelIndicesCurrencies_,
-                                             simulationDates_, mcParams_, 0, iborFallbackConfig, std::vector<Size>(),
-                                             conditionalExpectationModelStates);
+    // effective time steps per year: zero for exact evolution, otherwise the pricing engine parameter
+    if (useCg_) {
+        modelCG_ = boost::make_shared<GaussianCamCG>(
+            camBuilder->model(), modelSize_, modelCcys_, modelCurves_, modelFxSpots_, modelIrIndices_, modelInfIndices_,
+            modelIndices_, modelIndicesCurrencies_, simulationDates_,
+            camBuilder->model()->discretization() == CrossAssetModel::Discretization::Exact ? 0 : timeStepsPerYear_,
+            iborFallbackConfig, std::vector<Size>(), conditionalExpectationModelStates);
+    } else {
+        model_ = boost::make_shared<GaussianCam>(
+            camBuilder->model(), modelSize_, modelCcys_, modelCurves_, modelFxSpots_, modelIrIndices_, modelInfIndices_,
+            modelIndices_, modelIndicesCurrencies_, simulationDates_, mcParams_,
+            camBuilder->model()->discretization() == CrossAssetModel::Discretization::Exact ? 0 : timeStepsPerYear_,
+            iborFallbackConfig, std::vector<Size>(), conditionalExpectationModelStates);
+    }
 
     modelBuilders_.insert(std::make_pair(id, camBuilder));
 }
@@ -1526,11 +1538,20 @@ void ScriptedTradeEngineBuilder::buildGaussianCamAMC(
     Handle<CrossAssetModel> projectedModel(
         getProjectedCrossAssetModel(amcCam_, selectedComponents, projectedStateProcessIndices));
 
-    // TODO hardcode timeStepsPerYear to 1 and exact discretisation (we might want Euler for AD...)
-    model_ = boost::make_shared<GaussianCam>(projectedModel, modelSize_, modelCcys_, modelCurves_, modelFxSpots_,
-                                             modelIrIndices_, modelInfIndices_, modelIndices_, modelIndicesCurrencies_,
-                                             simulationDates_, mcParams_, 1, iborFallbackConfig,
-                                             projectedStateProcessIndices, conditionalExpectationModelStates);
+    // effective time steps per year: zero for exact evolution, otherwise the pricing engine parameter
+    if (useCg_) {
+        modelCG_ = boost::make_shared<GaussianCamCG>(
+            projectedModel, modelSize_, modelCcys_, modelCurves_, modelFxSpots_, modelIrIndices_, modelInfIndices_,
+            modelIndices_, modelIndicesCurrencies_, simulationDates_,
+            projectedModel->discretization() == CrossAssetModel::Discretization::Exact ? 0 : timeStepsPerYear_,
+            iborFallbackConfig, projectedStateProcessIndices, conditionalExpectationModelStates);
+    } else {
+        model_ = boost::make_shared<GaussianCam>(
+            projectedModel, modelSize_, modelCcys_, modelCurves_, modelFxSpots_, modelIrIndices_, modelInfIndices_,
+            modelIndices_, modelIndicesCurrencies_, simulationDates_, mcParams_,
+            projectedModel->discretization() == CrossAssetModel::Discretization::Exact ? 0 : timeStepsPerYear_,
+            iborFallbackConfig, projectedStateProcessIndices, conditionalExpectationModelStates);
+    }
 
     DLOG("built GuassianCam model as projection of xva evolution model");
     for (auto const& p : projectedStateProcessIndices)

OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.cpp

@@ -73,8 +73,8 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
     QL_REQUIRE(!useExternalComputeFramework_ || !useCachedSensis_,
                "ScriptedInstrumentPricingEngineCG: when using external compute framework, usage of cached sensis is "
                "not supported yet");
-    QL_REQUIRE(model_->trainingPaths() == Null<Size>(), "ScriptedInstrumentPricingEngineCG: separate training phase "
-                                                        "not supported, trainingSamples can not be specified.");
+    QL_REQUIRE(model_->trainingSamples() == Null<Size>(), "ScriptedInstrumentPricingEngineCG: separate training phase "
+                                                          "not supported, trainingSamples can not be specified.");
 
     lastCalculationWasValid_ = false;
 
@@ -131,8 +131,8 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
             opsExternal_ = getExternalRandomVariableOps();
             gradsExternal_ = getExternalRandomVariableGradients();
         } else {
-            ops_ = getRandomVariableOps(model_->size());
-            grads_ = getRandomVariableGradients(model_->size());
+            ops_ = getRandomVariableOps(model_->size(), mcParams_.regressionOrder, mcParams_.polynomType);
+            grads_ = getRandomVariableGradients(model_->size(), mcParams_.regressionOrder, mcParams_.polynomType);
         }
 
         // build graph
@@ -272,7 +272,8 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
         // extract npv result and set it
 
         if (useExternalComputeFramework_) {
-            ComputeEnvironment::instance().context().finalizeCalculation(externalOutputPtr_);
+            ComputeEnvironment::instance().context().finalizeCalculation(externalOutputPtr_,
+                                                                         {mcParams_.regressionOrder});
             baseNpv_ = results_.value = externalAverage(externalOutput_[0]);
         } else {
             baseNpv_ = results_.value = model_->extractT0Result(values[baseNpvNode]);

OREData/ored/scripting/models/amcmodel.hpp

@@ -23,23 +23,11 @@
 
 #pragma once
 
-#include <ored/scripting/value.hpp>
-
-#include <qle/models/modelbuilder.hpp>
-
-#include <qle/processes/crossassetstateprocess.hpp>
-
-#include <ql/patterns/lazyobject.hpp>
-#include <ql/settings.hpp>
-#include <ql/time/daycounters/actualactual.hpp>
-
-#include <boost/enable_shared_from_this.hpp>
+#include <qle/math/randomvariable.hpp>
 
 namespace ore {
 namespace data {
 
-using QuantLib::Date;
-
 class AmcModel {
 public:
     virtual ~AmcModel() {}

OREData/ored/scripting/models/amcmodelcg.hpp

@@ -0,0 +1,27 @@
+/*
+ Copyright (C) 2023 Quaternion Risk Management Ltd
+ All rights reserved.
+*/
+
+/*! \file models/amcmodelcg.hpp
+    \brief additional interface for amc enabled models
+    \ingroup utilities
+*/
+
+#pragma once
+
+#include <qle/math/randomvariable.hpp>
+
+namespace ore {
+namespace data {
+
+class AmcModelCG {
+public:
+    virtual ~AmcModelCG() {}
+    virtual void injectPaths(const std::vector<QuantLib::Real>* pathTimes,
+                             const std::vector<std::vector<std::size_t>>* variates,
+                             const std::vector<bool>* isRelevantTime, const bool stickyCloseOutRun) = 0;
+};
+
+} // namespace data
+} // namespace ore

OREData/ored/scripting/models/blackscholesbase.cpp

@@ -264,11 +264,10 @@ RandomVariable BlackScholesBase::npv(const RandomVariable& amount, const Date& o
         return expectation(amount);
     }
 
-    // generate basis if not yet done
+    // get basis fns
 
-    if (basisFns_.find(state.size()) == basisFns_.end())
-        basisFns_[state.size()] = multiPathBasisSystem(state.size(), mcParams_.regressionOrder, mcParams_.polynomType,
-                                                       std::min(size(), trainingSamples()));
+    auto basisFns = multiPathBasisSystem(state.size(), mcParams_.regressionOrder, mcParams_.polynomType,
+                                         std::min(trainingSamples(), Model::size()));
 
     // if a memSlot is given and coefficients are stored, we use them
 
@@ -288,8 +287,7 @@ RandomVariable BlackScholesBase::npv(const RandomVariable& amount, const Date& o
     // otherwise compute coefficients and store them if a memSlot is given
 
     if (coeff.size() == 0) {
-        coeff = regressionCoefficients(amount, state, basisFns_.at(state.size()), filter,
-                                       RandomVariableRegressionMethod::QR);
+        coeff = regressionCoefficients(amount, state, basisFns, filter, RandomVariableRegressionMethod::QR);
         DLOG("BlackScholesBase::npv(" << ore::data::to_string(obsdate) << "): regression coefficients are " << coeff
                                       << " (got model state size " << nModelStates << " and " << nAddReg
                                       << " additional regressors)");
@@ -299,7 +297,7 @@ RandomVariable BlackScholesBase::npv(const RandomVariable& amount, const Date& o
 
     // compute conditional expectation and return the result
 
-    return conditionalExpectation(state, basisFns_.at(state.size()), coeff);
+    return conditionalExpectation(state, basisFns, coeff);
 }
 
 void BlackScholesBase::releaseMemory() {

OREData/ored/scripting/models/blackscholesbase.hpp

@@ -103,8 +103,6 @@ class BlackScholesBase : public ModelImpl {
     const std::vector<Date> simulationDates_;
 
     // these all except underlyingPaths_ are initialised when the interface functions above are called
-    mutable std::map<Size, std::vector<std::function<RandomVariable(const std::vector<const RandomVariable*>&)>>>
-        basisFns_;
     mutable Date referenceDate_;                      // the model reference date
     mutable std::set<Date> effectiveSimulationDates_; // the dates effectively simulated (including today)
     mutable TimeGrid timeGrid_;                       // the (possibly refined) time grid for the simulation

OREData/ored/scripting/models/blackscholescg.cpp

@@ -247,7 +247,7 @@ void BlackScholesCG::performCalculations() const {
     if (indices_.empty() || !underlyingPaths_.empty())
         return;
 
-    // exit if only one simulation date in the future
+    // exit if there are no future simulation dates (i.e. only the reference date)
 
     if (effectiveSimulationDates_.size() == 1)
         return;
@@ -302,11 +302,10 @@ void BlackScholesCG::performCalculations() const {
         for (Size j = 0; j < indices_.size(); ++j) {
             for (Size k = 0; k < indices_.size(); ++k) {
                 std::string id = "__sqrtCov_" + std::to_string(j) + "_" + std::to_string(k) + "_" + std::to_string(i);
-                addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->sqrtCov(i, j, k); });
-                sqrtCov[i][j][k] = cg_var(*g_, id);
+                sqrtCov[i][j][k] =
+                    addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->sqrtCov(i, j, k); });
                 id = "__cov_" + std::to_string(j) + "_" + std::to_string(k) + "_" + std::to_string(i);
-                addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->cov(i, j, k); });
-                cov[i][j][k] = cg_var(*g_, id);
+                cov[i][j][k] = addModelParameter(id, [sqrtCovCalc, i, j, k] { return sqrtCovCalc->cov(i, j, k); });
             }
         }
     }
@@ -333,9 +332,9 @@ void BlackScholesCG::performCalculations() const {
         for (Size j = 0; j < indices_.size(); ++j) {
             auto p = model_->processes().at(j);
             std::string id = std::to_string(j) + "_" + ore::data::to_string(d);
-            addModelParameter("__div_" + id, [p, d]() { return p->dividendYield()->discount(d); });
-            addModelParameter("__rfr_" + id, [p, d]() { return p->riskFreeRate()->discount(d); });
-            std::size_t tmp = cg_div(*g_, cg_var(*g_, "__rfr_" + id), cg_var(*g_, "__div_" + id));
+            std::size_t div= addModelParameter("__div_" + id, [p, d]() { return p->dividendYield()->discount(d); });
+            std::size_t rfr = addModelParameter("__rfr_" + id, [p, d]() { return p->riskFreeRate()->discount(d); });
+            std::size_t tmp = cg_div(*g_, rfr, div);
             drift[i][j] = cg_subtract(*g_, cg_negative(*g_, cg_log(*g_, cg_div(*g_, tmp, discountRatio[j]))),
                                       cg_mult(*g_, cg_const(*g_, 0.5), cov[i][j][j]));
             discountRatio[j] = tmp;
@@ -353,7 +352,8 @@ void BlackScholesCG::performCalculations() const {
 
     for (Size j = 0; j < indices_.size(); ++j) {
         for (Size i = 0; i < effectiveSimulationDates_.size() - 1; ++i) {
-            randomVariates_[j][i] = cg_var(*g_, "__rv_" + std::to_string(j) + "_" + std::to_string(i), true);
+            randomVariates_[j][i] = cg_var(*g_, "__rv_" + std::to_string(j) + "_" + std::to_string(i),
+                                           ComputationGraph::VarDoesntExist::Create);
         }
     }
 
@@ -363,8 +363,7 @@ void BlackScholesCG::performCalculations() const {
     for (Size j = 0; j < indices_.size(); ++j) {
         std::string id = "__x0_" + std::to_string(j);
         auto p = model_->processes().at(j);
-        addModelParameter(id, [p] { return std::log(p->x0()); });
-        logState[j] = cg_var(*g_, id);
+        logState[j] = addModelParameter(id, [p] { return std::log(p->x0()); });
         underlyingPaths_[*effectiveSimulationDates_.begin()][j] = cg_exp(*g_, logState[j]);
     }