QPR-12417 generate past cashflows in scripted trade

Author: pcaspers

Docs/ScriptedTrade/docs/language.tex

@@ -466,7 +466,8 @@
 \item here $P_{ccy}$ is the discount factor in currency ccy, $FX$ is the FX spot from ccy to base and $N$ is the model
   numeraire
 \item $d\leq p$ must hold
-\item if $p$ lies on or before the evaluation date, the result is zero; $X$ is not evaluated in this case
+\item if $p$ lies on or before the evaluation date, the result is zero; $X$ is not evaluated in this case. 
+Note that $X$ is evaluated in the LOGPAY function if past cashflows are included, see \ref{function_logpay}.
 \item avoids reading non-relevant past fixings from the index history
 \item if $d$ lies before (but $p$ after) the evaluation date, it is set to the evaluation date, i.e. the result is
   computed as of the evaluation date
@@ -514,6 +515,9 @@
 under leg number $2$ and flow Type ``Interest''. The same holds for Payoff3, but if any amounts were booked using the
 slot parameter $3$ previously they will be overwritten with the current amount.
 
+Note: If IncludePastCashflows in the pricing engine config is set to true then even if $p$ lies on or before the
+evaluation date, a cashflow entry will be generated.
+
 % ====================================================
 \stsubsection{Function {\tt NPV, NPVMEM}}\label{function_npv}
 % ====================================================

Docs/ScriptedTrade/docs/models.tex

@@ -49,6 +49,7 @@ \subsection{Pricing Engine Configuration}\label{pricingengine_config}
       <Parameter name="TimeStepsPerYear">24</Parameter>
       <Parameter name="Interactive">false</Parameter>
       <Parameter name="BootstrapTolerance">0.1</Parameter>
+      <Parameter name="IncludePastCashflows">true</Parameter>
       <!-- product specific parameters -->
       <Parameter name="RegressionOrder_SingleAssetOption(EQ)">6</Parameter>
       <Parameter name="RegressionOrder_SingleAssetOption(FX)">6</Parameter>
@@ -136,6 +137,8 @@ \subsection{Pricing Engine Configuration}\label{pricingengine_config}
   only. The moneyness is defined as a ``standardised moneyness'' $\ln(K/F) / \sigma\sqrt{t}$ with $K$ strike, $F$ ATMF
   forward, $\sigma$ ATMF market vol, $t$ option time to expiry
 \item BootstrapTolerance: tolerance for calibration bootstrap, only applies to model = GaussianCam
+\item IncludePastCashflows: if true, LOGPAY() will generate cashflow information for pay dates on or before the
+  reference date. Optional, defaults to false.
 \item Interactive: If true an interactive session is started on script execution for debugging purposes; should be false
   except for debugging purposes
 \item UseAD: If true and RunType in the global pricing engine parameters is SensitivityDelta, a first order pnl

OREAnalytics/orea/app/reportwriter.cpp

@@ -580,6 +580,11 @@ void ReportWriter::writeCashflow(ore::data::Report& report, const std::string& b
                     if (cf.effectiveCapVolatility != Null<Real>())
                         capVolatility = cf.effectiveCapVolatility;
 
+                    // to be consistent with the leg-based cf report we should do this:
+                    // if (!includePastCashflows && cf.payDate <= asof)
+                    //     continue;
+                    // however, this changes a lot of results, so we output all cfs for the time being
+
                     report.next()
                         .add(trade->id())
                         .add(trade->tradeType())

OREData/ored/portfolio/builders/scriptedtrade.cpp

@@ -320,14 +320,14 @@ ScriptedTradeEngineBuilder::engine(const std::string& id, const ScriptedTrade& s
         engine = boost::make_shared<ScriptedInstrumentPricingEngine>(
             script.npv(), script.results(), model_, ast_, context, script.code(), interactive_, amcCam_ != nullptr,
             std::set<std::string>(script.stickyCloseOutStates().begin(), script.stickyCloseOutStates().end()),
-            generateAdditionalResults);
+            generateAdditionalResults, includePastCashflows_);
     } else if (modelCG_) {
         auto rt = globalParameters_.find("RunType");
         bool useCachedSensis = useAd_ && (rt != globalParameters_.end() && rt->second == "SensitivityDelta");
         bool useExternalDev = useExternalComputeDevice_ && !generateAdditionalResults && !useCachedSensis;
         engine = boost::make_shared<ScriptedInstrumentPricingEngineCG>(
             script.npv(), script.results(), modelCG_, ast_, context, mcParams_, script.code(), interactive_,
-            generateAdditionalResults, useCachedSensis, useExternalDev);
+            generateAdditionalResults, includePastCashflows_, useCachedSensis, useExternalDev);
         if (useExternalDev) {
             ComputeEnvironment::instance().selectContext(externalComputeDevice_);
         }
@@ -485,6 +485,7 @@ void ScriptedTradeEngineBuilder::populateModelParameters() {
     useExternalComputeDevice_ =
         parseBool(engineParameter("UseExternalComputeDevice", {resolvedProductTag_}, false, "false"));
     externalComputeDevice_ = engineParameter("ExternalComputeDevice", {}, false, "");
+    includePastCashflows_ = parseBool(engineParameter("IncludePastCashflows", {resolvedProductTag_}, false, "false"));
 
     // usage of ad or an external device implies usage of cg
     if (useAd_ || useExternalComputeDevice_)

OREData/ored/portfolio/builders/scriptedtrade.hpp

@@ -161,6 +161,7 @@ class ScriptedTradeEngineBuilder : public EngineBuilder {
     bool useAd_;
     bool useExternalComputeDevice_;
     std::string externalComputeDevice_;
+    bool includePastCashflows_;
 };
 
 } // namespace data

OREData/ored/scripting/computationgraphbuilder.cpp

@@ -119,12 +119,12 @@ class ASTRunner : public AcyclicVisitor,
                   public Visitor<LoopNode> {
 public:
     ASTRunner(ComputationGraph& g, const std::vector<std::string>& opLabels, const boost::shared_ptr<ModelCG> model,
-              const bool generatePayLog, const std::string& script, bool& interactive, Context& context,
-              ASTNode*& lastVisitedNode, std::set<std::size_t>& keepNodes,
+              const bool generatePayLog, const bool includePastCashflows, const std::string& script, bool& interactive,
+              Context& context, ASTNode*& lastVisitedNode, std::set<std::size_t>& keepNodes,
               std::vector<ComputationGraphBuilder::PayLogEntry>& payLogEntries)
         : g_(g), opLabels_(opLabels), model_(model), size_(model ? model->size() : 1), generatePayLog_(generatePayLog),
-          script_(script), interactive_(interactive), keepNodes_(keepNodes), payLogEntries_(payLogEntries),
-          context_(context), lastVisitedNode_(lastVisitedNode) {
+          includePastCashflows_(includePastCashflows), script_(script), interactive_(interactive),
+          keepNodes_(keepNodes), payLogEntries_(payLogEntries), context_(context), lastVisitedNode_(lastVisitedNode) {
         filter.emplace(size_, true);
         value.push(RandomVariable());
         filter_node.push(ComputationGraph::nan);
@@ -1029,7 +1029,7 @@ class ASTRunner : public AcyclicVisitor,
         QL_REQUIRE(model_, "model is null");
         // handle case of past payments: do not evaluate the other parameters, since not needed (e.g. past fixings)
         Date pay = boost::get<EventVec>(paydate).value;
-        if (pay <= model_->referenceDate()) {
+        if (pay <= model_->referenceDate() && (!log || !includePastCashflows_)) {
             value.push(RandomVariable(size_, 0.0));
             std::size_t node = cg_const(g_, 0.0);
             value_node.push(node);
@@ -1053,7 +1053,9 @@ class ASTRunner : public AcyclicVisitor,
             QL_REQUIRE(obs <= pay, "observation date (" << obs << ") <= payment date (" << pay << ") required");
             RandomVariable result; // uninitialised, since model dependent
             value.push(result);
-            std::size_t node = model_->pay(amount_node, obs, pay, pccy);
+            std::size_t node =
+                pay <= model_->referenceDate() ? cg_const(g_, 0.0) : model_->pay(amount_node, obs, pay, pccy);
+            std::size_t cfnode = pay <= model_->referenceDate() ? amount_node : node;
             value_node.push(node);
             TRACE("pay( " << amount << " , " << obsdate << " , " << paydate << " , " << paycurr << " ) (#" << node
                           << ")",
@@ -1092,10 +1094,10 @@ class ASTRunner : public AcyclicVisitor,
                 }
                 // add nodes necessary to write paylog to keepNodes set
                 std::size_t filterNode =  filter_node.top() == ComputationGraph::nan ? cg_const(g_, 1.0) : filter_node.top();
-                keepNodes_.insert(node);
+                keepNodes_.insert(cfnode);
                 keepNodes_.insert(filterNode);
                 // add paylog entry data
-                payLogEntries_.push_back({node, filterNode, obs, pay, pccy, (Size)legno, cftype, (Size)slot});
+                payLogEntries_.push_back({cfnode, filterNode, obs, pay, pccy, (Size)legno, cftype, (Size)slot});
             }
         }
     }
@@ -1463,6 +1465,7 @@ class ASTRunner : public AcyclicVisitor,
     const boost::shared_ptr<ModelCG> model_;
     const Size size_;
     const bool generatePayLog_;
+    const bool includePastCashflows_;
     const std::string script_;
     bool& interactive_;
     std::set<std::size_t>& keepNodes_;
@@ -1479,14 +1482,15 @@ class ASTRunner : public AcyclicVisitor,
 
 } // namespace
 
-void ComputationGraphBuilder::run(const bool generatePayLog, const std::string& script, bool interactive) {
+void ComputationGraphBuilder::run(const bool generatePayLog, const bool includePastCashflows, const std::string& script,
+                                  bool interactive) {
 
     keepNodes_.clear();
     payLogEntries_.clear();
 
     ASTNode* loc;
-    ASTRunner runner(g_, opLabels_, model_, generatePayLog, script, interactive, *context_, loc, keepNodes_,
-                     payLogEntries_);
+    ASTRunner runner(g_, opLabels_, model_, generatePayLog, generatePayLog && includePastCashflows, script, interactive,
+                     *context_, loc, keepNodes_, payLogEntries_);
 
     randomvariable_output_pattern pattern;
     if (model_ == nullptr || model_->type() == ModelCG::Type::MC) {

OREData/ored/scripting/computationgraphbuilder.hpp

@@ -49,7 +49,8 @@ class ComputationGraphBuilder {
     ComputationGraphBuilder(ComputationGraph& g, const std::vector<std::string>& opLabels, const ASTNodePtr root,
                             const boost::shared_ptr<Context> context, const boost::shared_ptr<ModelCG> model = nullptr)
         : g_(g), opLabels_(opLabels), root_(root), context_(context), model_(model) {}
-    void run(const bool generatePayLog, const std::string& script = "", bool interactive = false);
+    void run(const bool generatePayLog, const bool includePastCashflows = false, const std::string& script = "",
+             bool interactive = false);
     const std::set<std::size_t>& keepNodes() const { return keepNodes_; }
     const std::vector<PayLogEntry>& payLogEntries() const { return payLogEntries_; }
 

OREData/ored/scripting/engines/scriptedinstrumentpricingengine.cpp

@@ -107,8 +107,12 @@ void ScriptedInstrumentPricingEngine::calculate() const {
     // set up script engine and run it
 
     ScriptEngine engine(ast_, workingContext, model_);
-    auto paylog = boost::make_shared<PayLog>();
-    engine.run(script_, interactive_, paylog);
+
+    boost::shared_ptr<PayLog> paylog;
+    if (generateAdditionalResults_)
+        paylog = boost::make_shared<PayLog>();
+
+    engine.run(script_, interactive_, paylog, includePastCashflows_);
 
     // extract npv result and set it
 
@@ -191,8 +195,12 @@ void ScriptedInstrumentPricingEngine::calculate() const {
         for (Size i = 0; i < paylog->size(); ++i) {
             // cashflow is written as expectation of deflated base ccy amount at T0, converted to flow ccy
             // with the T0 FX Spot and compounded back to the pay date on T0 curves
-            Real fx = model_->fxSpotT0(paylog->currencies().at(i), model_->baseCcy());
-            Real discount = model_->discount(referenceDate, paylog->dates().at(i), paylog->currencies().at(i)).at(0);
+            Real fx = 1.0;
+            Real discount = 1.0;
+            if (paylog->dates().at(i) > model_->referenceDate()) {
+                fx = model_->fxSpotT0(paylog->currencies().at(i), model_->baseCcy());
+                discount = model_->discount(referenceDate, paylog->dates().at(i), paylog->currencies().at(i)).at(0);
+            }
             cashFlowResults[i].amount = model_->extractT0Result(paylog->amounts().at(i)) / fx / discount;
             cashFlowResults[i].payDate = paylog->dates().at(i);
             cashFlowResults[i].currency = paylog->currencies().at(i);
@@ -202,10 +210,12 @@ void ScriptedInstrumentPricingEngine::calculate() const {
                                  << cashFlowResults[i].currency << cashFlowResults[i].amount << " "
                                  << cashFlowResults[i].currency << "-" << model_->baseCcy() << " " << fx << " discount("
                                  << cashFlowResults[i].currency << ") " << discount);
-            addMcErrorEstimate("cashflow_" + std::to_string(paylog->legNos().at(i)) + "_" +
-                                   std::to_string(++cashflowNumber[paylog->legNos().at(i)]) + "_MCErrEst",
-                               paylog->amounts().at(i) /
-                                   RandomVariable(paylog->amounts().at(i).size(), (fx * discount)));
+            if (paylog->dates().at(i) > model_->referenceDate()) {
+                addMcErrorEstimate("cashflow_" + std::to_string(paylog->legNos().at(i)) + "_" +
+                                       std::to_string(++cashflowNumber[paylog->legNos().at(i)]) + "_MCErrEst",
+                                   paylog->amounts().at(i) /
+                                       RandomVariable(paylog->amounts().at(i).size(), (fx * discount)));
+            }
         }
         results_.additionalResults["cashFlowResults"] = cashFlowResults;
 

OREData/ored/scripting/engines/scriptedinstrumentpricingengine.hpp

@@ -34,15 +34,18 @@ namespace data {
 
 class ScriptedInstrumentPricingEngine : public QuantExt::ScriptedInstrument::engine {
 public:
-    ScriptedInstrumentPricingEngine(
-        const std::string& npv, const std::vector<std::pair<std::string, std::string>>& additionalResults,
-        const boost::shared_ptr<Model>& model, const ASTNodePtr ast, const boost::shared_ptr<Context>& context,
-        const std::string& script = "", const bool interactive = false,
-        const bool amcEnabled = false,
-        const std::set<std::string>& amcStickyCloseOutStates = {}, const bool generateAdditionalResults = false)
+    ScriptedInstrumentPricingEngine(const std::string& npv,
+                                    const std::vector<std::pair<std::string, std::string>>& additionalResults,
+                                    const boost::shared_ptr<Model>& model, const ASTNodePtr ast,
+                                    const boost::shared_ptr<Context>& context, const std::string& script = "",
+                                    const bool interactive = false, const bool amcEnabled = false,
+                                    const std::set<std::string>& amcStickyCloseOutStates = {},
+                                    const bool generateAdditionalResults = false,
+                                    const bool includePastCashflows = false)
         : npv_(npv), additionalResults_(additionalResults), model_(model), ast_(ast), context_(context),
           script_(script), interactive_(interactive), amcEnabled_(amcEnabled),
-          amcStickyCloseOutStates_(amcStickyCloseOutStates), generateAdditionalResults_(generateAdditionalResults) {
+          amcStickyCloseOutStates_(amcStickyCloseOutStates), generateAdditionalResults_(generateAdditionalResults),
+          includePastCashflows_(includePastCashflows) {
         registerWith(model_);
     }
 
@@ -65,6 +68,7 @@ class ScriptedInstrumentPricingEngine : public QuantExt::ScriptedInstrument::eng
     const bool amcEnabled_;
     const std::set<std::string> amcStickyCloseOutStates_;
     const bool generateAdditionalResults_;
+    const bool includePastCashflows_;
 };
 
 } // namespace data

OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.cpp

@@ -68,11 +68,12 @@ ScriptedInstrumentPricingEngineCG::ScriptedInstrumentPricingEngineCG(
     const std::string& npv, const std::vector<std::pair<std::string, std::string>>& additionalResults,
     const boost::shared_ptr<ModelCG>& model, const ASTNodePtr ast, const boost::shared_ptr<Context>& context,
     const Model::McParams& mcParams, const std::string& script, const bool interactive,
-    const bool generateAdditionalResults, const bool useCachedSensis, const bool useExternalComputeFramework)
+    const bool generateAdditionalResults, const bool includePastCashflows, const bool useCachedSensis,
+    const bool useExternalComputeFramework)
     : npv_(npv), additionalResults_(additionalResults), model_(model), ast_(ast), context_(context),
       mcParams_(mcParams), script_(script), interactive_(interactive),
-      generateAdditionalResults_(generateAdditionalResults), useCachedSensis_(useCachedSensis),
-      useExternalComputeFramework_(useExternalComputeFramework) {
+      generateAdditionalResults_(generateAdditionalResults), includePastCashflows_(includePastCashflows),
+      useCachedSensis_(useCachedSensis), useExternalComputeFramework_(useExternalComputeFramework) {
 
     // register with model
 
@@ -138,7 +139,7 @@ void ScriptedInstrumentPricingEngineCG::buildComputationGraph() const {
         // build graph
 
         ComputationGraphBuilder cgBuilder(*g, getRandomVariableOpLabels(), ast_, workingContext_, model_);
-        cgBuilder.run(generateAdditionalResults_, script_, interactive_);
+        cgBuilder.run(generateAdditionalResults_, includePastCashflows_, script_, interactive_);
         cgVersion_ = model_->cgVersion();
         DLOG("Built computation graph version " << cgVersion_ << " size is " << g->size());
         TLOGGERSTREAM(ssaForm(*g, getRandomVariableOpLabels()));
@@ -384,8 +385,12 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
             for (Size i = 0; i < paylog->size(); ++i) {
                 // cashflow is written as expectation of deflated base ccy amount at T0, converted to flow ccy
                 // with the T0 FX Spot and compounded back to the pay date on T0 curves
-                Real fx = model_->getDirectFxSpotT0(paylog->currencies().at(i), model_->baseCcy());
-                Real discount = model_->getDirectDiscountT0(paylog->dates().at(i), paylog->currencies().at(i));
+                Real fx = 1.0;
+                Real discount = 1.0;
+                if (paylog->dates().at(i) > model_->referenceDate()) {
+                    fx = model_->getDirectFxSpotT0(paylog->currencies().at(i), model_->baseCcy());
+                    discount = model_->getDirectDiscountT0(paylog->dates().at(i), paylog->currencies().at(i));
+                }
                 cashFlowResults[i].amount = model_->extractT0Result(paylog->amounts().at(i)) / fx / discount;
                 cashFlowResults[i].payDate = paylog->dates().at(i);
                 cashFlowResults[i].currency = paylog->currencies().at(i);