QPR-12123 add conversion indicator pv as additional results

Author: pcaspers

QuantExt/qle/pricingengines/fddefaultableequityjumpdiffusionconvertiblebondengine.cpp

@@ -278,10 +278,14 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
 
     Size n = mesher_->locations().size();
     std::vector<Array> value(stochasticConversionRatios.size(), Array(n, 0.0)), valueTmp;
+    std::vector<Array> conversionIndicator;
+    if (generateAdditionalResults_)
+        conversionIndicator.resize(stochasticConversionRatios.size(), Array(n, 0.0));
 
     // 10 add no-conversion variants for start of period coco feature
 
     std::vector<Array> valueNoConversion, valueNoConversionTmp;
+    std::vector<Array> conversionIndicatorNoConversion;
 
     // 11 perform the backward PDE pricing
 
@@ -309,12 +313,14 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
                 Real cr = value.size() > 1 ? stochasticConversionRatios[plane] : events.getCurrentConversionRatio(i);
                 for (Size j = 0; j < n; ++j) {
                     bool cocoTriggered = true;
-                   if (events.hasContingentConversion(i) && !events.hasNoConversionPlane(i)) {
+                    if (events.hasContingentConversion(i) && !events.hasNoConversionPlane(i)) {
                         cocoTriggered = cr * S[j] > events.getConversionData(i).cocoBarrier;
                         // update value from no conversion plane, if there is one and coco is not triggered
                         if (!valueNoConversion.empty()) {
                             if (!cocoTriggered) {
                                 value[plane][j] = valueNoConversion[plane][j];
+                                if (!conversionIndicator.empty())
+                                    conversionIndicator[plane][j] = conversionIndicatorNoConversion[plane][j];
                             }
                         }
                     }
@@ -323,6 +329,8 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
                     if (cocoTriggered && exerciseValue > value[plane][j] + events.getBondFinalRedemption(i)) {
                         value[plane][j] = exerciseValue;
                         conversionExercised[plane][j] = true;
+                        if (!conversionIndicator.empty())
+                            conversionIndicator[plane][j] = 1.0;
                     }
                 }
             }
@@ -332,6 +340,7 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
 
         if (events.hasContingentConversion(i) && !events.hasNoConversionPlane(i) && !valueNoConversion.empty()) {
             valueNoConversion.clear();
+            conversionIndicatorNoConversion.clear();
         }
 
         // 11.4 handle cr / DP induced cr resets and resets to specific value on t_i
@@ -372,9 +381,8 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
                                         std::min(adjustedConversionRatio[j], N0 / (rd.globalFloor * referenceCP));
                                 }
                                 adjustedConversionRatio[j] =
-                                    std::max(cr,
-                                             adjustedConversionRatio[j] != QL_MAX_REAL ? adjustedConversionRatio[j]
-                                                                                       : -QL_MAX_REAL);
+                                    std::max(cr, adjustedConversionRatio[j] != QL_MAX_REAL ? adjustedConversionRatio[j]
+                                                                                           : -QL_MAX_REAL);
                             }
                         }
                     }
@@ -447,6 +455,21 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
                 }
                 valueNoConversion = std::vector<Array>(1, collapsedValue);
             }
+            if (!conversionIndicator.empty()) {
+                for (Size j = 0; j < n; ++j) {
+                    collapsedValue[j] = interpolateValueFromPlanes(events.getCurrentConversionRatio(i),
+                                                                   conversionIndicator, stochasticConversionRatios, j);
+                }
+                conversionIndicator = std::vector<Array>(1, collapsedValue);
+            }
+            if (!conversionIndicatorNoConversion.empty()) {
+                for (Size j = 0; j < n; ++j) {
+                    collapsedValue[j] =
+                        interpolateValueFromPlanes(events.getCurrentConversionRatio(i), conversionIndicatorNoConversion,
+                                                   stochasticConversionRatios, j);
+                }
+                conversionIndicatorNoConversion = std::vector<Array>(1, collapsedValue);
+            }
         }
 
         for (Size plane = 0; plane < value.size(); ++plane) {
@@ -469,6 +492,10 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
                     conversionExercised[plane][j] = true;
                     if (!valueNoConversion.empty())
                         valueNoConversion[plane][j] = payoff;
+                    if (!conversionIndicator.empty())
+                        conversionIndicator[plane][j] = 1.0;
+                    if (!conversionIndicatorNoConversion.empty())
+                        conversionIndicatorNoConversion[plane][j] = 1.0;
                 }
             }
 
@@ -559,6 +586,10 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
             solver->rollback(value[plane], t_from, t_to, 1, 0);
             if (!valueNoConversion.empty())
                 solver->rollback(valueNoConversion[plane], t_from, t_to, 1, 0);
+            if (!conversionIndicator.empty())
+                solver->rollback(conversionIndicator[plane], t_from, t_to, 1, 0);
+            if (!conversionIndicatorNoConversion.empty())
+                solver->rollback(conversionIndicatorNoConversion[plane], t_from, t_to, 1, 0);
 
         } // loop over stochastic conversion ratio planes
 
@@ -624,7 +655,8 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
            << "|" << std::setw(width) << "eq_fwd"
            << "|" << std::setw(width) << "div_amt"
            << "|" << std::setw(width) << "conv_val"
-           << "|" << std::setw(width) << "conv_prc" << "|";
+           << "|" << std::setw(width) << "conv_prc"
+           << "|";
 
     results_.additionalResults["event_0000!"] = header.str();
 
@@ -750,7 +782,7 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
     results_.additionalResults["market.creditSpread(tMax)"] =
         -std::log(model_->creditCurve()->survivalProbability(tMax)) / tMax;
     if (!creditCurve_.empty()) {
-       results_.additionalResults["market.exchangeableBondSpread(tMax)"] =
+        results_.additionalResults["market.exchangeableBondSpread(tMax)"] =
             -std::log(creditCurve_->survivalProbability(tMax)) / tMax;
     }
     results_.additionalResults["market.recoveryRate"] = recoveryRate_.empty() ? 0.0 : recoveryRate_->value();
@@ -765,6 +797,10 @@ void FdDefaultableEquityJumpDiffusionConvertibleBondEngine::calculate() const {
     results_.additionalResults["model.calibrationTimes"] = model_->stepTimes();
     results_.additionalResults["model.h0"] = model_->h0();
     results_.additionalResults["model.sigma"] = model_->sigma();
+
+    MonotonicCubicNaturalSpline interpolationConversionIndicator(
+        mesher_->locations().begin(), mesher_->locations().end(), conversionIndicator[0].begin());
+    results_.additionalResults["conversionIndicator"] = interpolationConversionIndicator(logSpot);
 }
 
 } // namespace QuantExt