QPR-10088: Settlment Lag for Physically Settled FXOption

pcaspers · jenkins · commit 48f6d64e5fad · 2024-02-20T12:18:12.000Z
diff --git a/OREData/ored/portfolio/builders/fxoption.cpp b/OREData/ored/portfolio/builders/fxoption.cpp
@@ -35,7 +35,7 @@ using namespace QuantExt;
 boost::shared_ptr<PricingEngine> CamAmcFxOptionEngineBuilder::engineImpl(const string& assetName,
                                                                          const Currency& domCcy,
                                                                          const AssetClass& assetClassUnderlying,
-                                                                         const Date& expiryDate) {
+                                                                         const Date& expiryDate, const bool useFxSpot) {
 
     QL_REQUIRE(assetClassUnderlying == AssetClass::FX, "FX Option required");
     Currency forCcy = parseCurrency(assetName);
diff --git a/OREData/ored/portfolio/builders/fxoption.hpp b/OREData/ored/portfolio/builders/fxoption.hpp
@@ -82,8 +82,7 @@ class CamAmcFxOptionEngineBuilder : public VanillaOptionEngineBuilder {
 protected:
     // the pricing engine depends on the ccys only, so the base class key implementation will just do fine
     boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
-                                                const AssetClass& assetClassUnderlying,
-                                                const Date& expiryDate) override;
+                                                const AssetClass& assetClassUnderlying, const Date& expiryDate, const bool useFxSpot) override;
 
 private:
     const boost::shared_ptr<QuantExt::CrossAssetModel> cam_;
diff --git a/OREData/ored/portfolio/builders/vanillaoption.hpp b/OREData/ored/portfolio/builders/vanillaoption.hpp
@@ -52,7 +52,8 @@ template <class T, typename... Args> class CachingOptionEngineBuilder : public C
     boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> getBlackScholesProcess(const string& assetName,
                                                                              const Currency& ccy,
                                                                              const AssetClass& assetClassUnderlying,
-                                                                             const std::vector<Time>& timePoints = {}) {
+                                                                             const std::vector<Time>& timePoints = {},
+                                                                             const bool useFxSpot = true) {
 
         using VVTS = QuantExt::BlackMonotoneVarVolTermStructure;
         string config = this->configuration(ore::data::MarketContext::pricing);
@@ -74,9 +75,15 @@ template <class T, typename... Args> class CachingOptionEngineBuilder : public C
                 vol = Handle<BlackVolTermStructure>(boost::make_shared<VVTS>(vol, timePoints));
                 vol->enableExtrapolation();
             }
+            if (useFxSpot) {
+                return boost::make_shared<QuantLib::GeneralizedBlackScholesProcess>(
+                    this->market_->fxSpot(ccyPairCode, config), this->market_->discountCurve(assetName, config),
+                    this->market_->discountCurve(ccy.code(), config), vol);
+            }
             return boost::make_shared<QuantLib::GeneralizedBlackScholesProcess>(
-                this->market_->fxSpot(ccyPairCode, config), this->market_->discountCurve(assetName, config),
+                this->market_->fxRate(ccyPairCode, config), this->market_->discountCurve(assetName, config),
                 this->market_->discountCurve(ccy.code(), config), vol);
+            
 
         } else if (assetClassUnderlying == AssetClass::COM) {
 
@@ -109,25 +116,26 @@ template <class T, typename... Args> class CachingOptionEngineBuilder : public C
     \ingroup builders
  */
 class VanillaOptionEngineBuilder
-    : public CachingOptionEngineBuilder<string, const string&, const Currency&, const AssetClass&, const Date&> {
+    : public CachingOptionEngineBuilder<string, const string&, const Currency&, const AssetClass&, const Date&, const bool> {
 public:
     VanillaOptionEngineBuilder(const string& model, const string& engine, const set<string>& tradeTypes,
                                const AssetClass& assetClass, const Date& expiryDate)
         : CachingOptionEngineBuilder(model, engine, tradeTypes, assetClass), expiryDate_(expiryDate) {}
 
-    boost::shared_ptr<PricingEngine> engine(const string& assetName, const Currency& ccy, const Date& expiryDate) {
+    boost::shared_ptr<PricingEngine> engine(const string& assetName, const Currency& ccy, const Date& expiryDate, const bool useFxSpot = true) {
         return CachingPricingEngineBuilder<string, const string&, const Currency&, const AssetClass&,
-                                           const Date&>::engine(assetName, ccy, assetClass_, expiryDate);
+                                           const Date&, const bool>::engine(assetName, ccy, assetClass_, expiryDate, useFxSpot);
     }
 
-    boost::shared_ptr<PricingEngine> engine(const Currency& ccy1, const Currency& ccy2, const Date& expiryDate) {
+    boost::shared_ptr<PricingEngine> engine(const Currency& ccy1, const Currency& ccy2, const Date& expiryDate,
+                                            const bool useFxSpot = true) {
         return CachingPricingEngineBuilder<string, const string&, const Currency&, const AssetClass&,
-                                           const Date&>::engine(ccy1.code(), ccy2, assetClass_, expiryDate);
+                                           const Date&, const bool>::engine(ccy1.code(), ccy2, assetClass_, expiryDate, useFxSpot);
     }
 
 protected:
     virtual string keyImpl(const string& assetName, const Currency& ccy, const AssetClass& assetClassUnderlying,
-                           const Date& expiryDate) override {
+                           const Date& expiryDate, const bool useFxSpot) override {
         return assetName + "/" + ccy.code() + "/" + to_string(expiryDate);
     }
 
@@ -147,7 +155,7 @@ class EuropeanOptionEngineBuilder : public VanillaOptionEngineBuilder {
 protected:
     virtual boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
                                                         const AssetClass& assetClassUnderlying,
-                                                        const Date& expiryDate) override {
+                                                        const Date& expiryDate, const bool useFxSpot) override {
         boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> gbsp =
             getBlackScholesProcess(assetName, ccy, assetClassUnderlying);
         Handle<YieldTermStructure> discountCurve =
@@ -168,8 +176,8 @@ class EuropeanForwardOptionEngineBuilder : public VanillaOptionEngineBuilder {
 
 protected:
     virtual boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
-                                                        const AssetClass& assetClassUnderlying,
-                                                        const Date& expiryDate) override {
+                                                        const AssetClass& assetClassUnderlying, const Date& expiryDate,
+                                                        const bool useFxSpot) override {
         boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> gbsp =
             getBlackScholesProcess(assetName, ccy, assetClassUnderlying);
         Handle<YieldTermStructure> discountCurve =
@@ -188,8 +196,8 @@ class EuropeanCSOptionEngineBuilder : public VanillaOptionEngineBuilder {
 
 protected:
     virtual boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
-                                                        const AssetClass& assetClassUnderlying,
-                                                        const Date& expiryDate) override {
+                                                        const AssetClass& assetClassUnderlying, const Date& expiryDate,
+                                                        const bool useFxSpot) override {
         boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> gbsp =
             getBlackScholesProcess(assetName, ccy, assetClassUnderlying);
         Handle<YieldTermStructure> discountCurve =
@@ -223,7 +231,8 @@ class AmericanOptionFDEngineBuilder : public AmericanOptionEngineBuilder {
 
 protected:
     virtual boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
-                                                        const AssetClass& assetClass, const Date& expiryDate) override {
+                                                        const AssetClass& assetClass, const Date& expiryDate,
+                                                        const bool useFxSpot) override {
         // We follow the way FdBlackScholesBarrierEngine determines maturity for time grid generation
         Handle<YieldTermStructure> riskFreeRate =
             market_->discountCurve(ccy.code(), configuration(ore::data::MarketContext::pricing));
@@ -271,7 +280,8 @@ class AmericanOptionBAWEngineBuilder : public AmericanOptionEngineBuilder {
 
 protected:
     virtual boost::shared_ptr<PricingEngine> engineImpl(const string& assetName, const Currency& ccy,
-                                                        const AssetClass& assetClass, const Date& expiryDate) override {
+                                                        const AssetClass& assetClass, const Date& expiryDate,
+                                                        const bool useFxSpot) override {
         boost::shared_ptr<QuantLib::GeneralizedBlackScholesProcess> gbsp = getBlackScholesProcess(assetName, ccy, assetClass);
         return boost::make_shared<QuantExt::BaroneAdesiWhaleyApproximationEngine>(gbsp);
     }
diff --git a/OREData/ored/portfolio/fxoption.cpp b/OREData/ored/portfolio/fxoption.cpp
@@ -18,11 +18,16 @@
 
 #include <boost/make_shared.hpp>
 #include <ored/portfolio/builders/fxoption.hpp>
+#include <ored/portfolio/builders/fxforward.hpp>
 #include <ored/portfolio/enginefactory.hpp>
 #include <ored/portfolio/fxoption.hpp>
+#include <ored/portfolio/fxforward.hpp>
 #include <ored/portfolio/legdata.hpp>
+#include <ored/portfolio/structuredtradewarning.hpp>
 #include <ored/utilities/log.hpp>
 #include <ored/utilities/marketdata.hpp>
+#include <ored/utilities/parsers.hpp>
+#include <qle/instruments/fxforward.hpp>
 #include <ql/errors.hpp>
 #include <ql/exercise.hpp>
 #include <ql/instruments/compositeinstrument.hpp>
@@ -35,6 +40,7 @@ namespace data {
 
 void FxOption::build(const boost::shared_ptr<EngineFactory>& engineFactory) {
 
+    QuantLib::Date today = Settings::instance().evaluationDate();
     const boost::shared_ptr<Market>& market = engineFactory->market();
 
     // If automatic exercise, check that we have a non-empty FX index string, parse it and attach curves from market.
@@ -54,8 +60,62 @@ void FxOption::build(const boost::shared_ptr<EngineFactory>& engineFactory) {
         indexName_ = fxIndex_;
     }
 
-    // Build the trade using the shared functionality in the base class.
-    VanillaOptionTrade::build(engineFactory);
+    const ext::optional<OptionPaymentData>& opd = option_.paymentData();
+    expiryDate_ = parseDate(option_.exerciseDates().front());
+    QuantLib::Date paymentDate = expiryDate_;
+    if (option_.settlement() == "Physical" && opd) {
+        if (opd->rulesBased()) {
+            const Calendar& cal = opd->calendar();
+            QL_REQUIRE(cal != Calendar(), "Need a non-empty calendar for rules based payment date.");
+            paymentDate = cal.advance(expiryDate_, opd->lag(), Days, opd->convention());
+        } else {
+            if (opd->dates().size() > 1)
+                ore::data::StructuredTradeWarningMessage(
+                    id(), tradeType(), "Trade build", "Found more than 1 payment date. The first one will be used.")
+                    .log();
+            paymentDate = opd->dates().front();
+        }
+
+        QL_REQUIRE(paymentDate >= expiryDate_, "Settlement date must be greater than or equal to expiry date.");
+
+        if (expiryDate_ <= today) {
+            // building an fx forward instrument instead of the option
+            Date fixingDate;
+            Currency boughtCcy = parseCurrency(assetName_);
+            Currency soldCcy = parseCurrency(currency_);
+            ext::shared_ptr<QuantLib::Instrument> instrument =
+                ext::make_shared<QuantExt::FxForward>(quantity_, boughtCcy, soldAmount(), soldCcy, maturity_, false,
+                                                        true, paymentDate, soldCcy, fixingDate);
+            instrument_.reset(new VanillaInstrument(instrument));
+            if (option_.exerciseData()) {
+                if (option_.exerciseData()->date() <= expiryDate_) {
+                    // option is exercised
+                    // fxforward flow are flows from trade data
+                    legs_ = {{ext::make_shared<SimpleCashFlow>(quantity_, paymentDate)},
+                                {ext::make_shared<SimpleCashFlow>(soldAmount(), paymentDate)}};
+                    legCurrencies_ = {assetName_, currency_};
+                    legPayers_ = {false, true};
+                } else
+                    QL_REQUIRE(option_.exerciseData()->date() <= expiryDate_,
+                                "Trade build error, exercise after option expiry is not allowed");
+            } else {
+                // option not exercised
+                // set flows = 0
+                legs_ = {};
+            }
+            forwardDate_ = paymentDate;
+            paymentDate_ = paymentDate;
+            VanillaOptionTrade::build(engineFactory);
+
+        } else {
+            // Build the trade using the shared functionality in the base class.
+            VanillaOptionTrade::build(engineFactory);
+        }
+        maturity_ = paymentDate;
+    } else {
+        VanillaOptionTrade::build(engineFactory);
+    }
+    
     
     additionalData_["boughtCurrency"] = assetName_; 
     additionalData_["boughtAmount"] = quantity_;
diff --git a/OREData/ored/portfolio/vanillaoption.cpp b/OREData/ored/portfolio/vanillaoption.cpp
@@ -186,7 +186,7 @@ void VanillaOptionTrade::build(const boost::shared_ptr<ore::data::EngineFactory>
         } else {
             QL_REQUIRE(exerciseType == QuantLib::Exercise::Type::European, "Only European Forward Options currently supported");
             LOG("Built VanillaForwardOption for trade " << id());
-            vanilla = boost::make_shared<QuantExt::VanillaForwardOption>(payoff, exercise, forwardDate_);
+            vanilla = boost::make_shared<QuantExt::VanillaForwardOption>(payoff, exercise, forwardDate_, paymentDate_);
             if (assetClassUnderlying_ == AssetClass::COM)
                 tradeTypeBuilder = tradeType_ + "Forward";
         }
@@ -212,8 +212,12 @@ void VanillaOptionTrade::build(const boost::shared_ptr<ore::data::EngineFactory>
                 boost::dynamic_pointer_cast<VanillaOptionEngineBuilder>(builder);
 	QL_REQUIRE(vanillaOptionBuilder != nullptr, "No engine builder found for trade type " << tradeTypeBuilder);
 
-	vanilla->setPricingEngine(vanillaOptionBuilder->engine(assetName_, ccy, expiryDate_));
-        setSensitivityTemplate(*vanillaOptionBuilder);
+    if (forwardDate_ != Date()) {
+        vanilla->setPricingEngine(vanillaOptionBuilder->engine(assetName_, ccy, expiryDate_, false));
+    } else {
+        vanilla->setPricingEngine(vanillaOptionBuilder->engine(assetName_, ccy, expiryDate_, true));
+    }
+    setSensitivityTemplate(*vanillaOptionBuilder);
 
 	configuration = vanillaOptionBuilder->configuration(MarketContext::pricing);
     } else {
diff --git a/OREData/ored/portfolio/vanillaoption.hpp b/OREData/ored/portfolio/vanillaoption.hpp
@@ -49,6 +49,7 @@ class VanillaOptionTrade : public Trade {
     TradeStrike strike() const { return strike_; }
     double quantity() const { return quantity_; }
     const QuantLib::Date forwardDate() const { return forwardDate_; }
+    const QuantLib::Date paymentDate() const { return paymentDate_; }
     //@}
 
     //! \name Serialisation
@@ -86,6 +87,9 @@ class VanillaOptionTrade : public Trade {
 
     //! Store the (optional) forward date.
     QuantLib::Date forwardDate_;
+
+    //! Store the (optional) payment date.
+    QuantLib::Date paymentDate_;
 };
 } // namespace data
 } // namespace ore
diff --git a/QuantExt/qle/instruments/vanillaforwardoption.hpp b/QuantExt/qle/instruments/vanillaforwardoption.hpp
@@ -36,6 +36,10 @@ namespace QuantExt {
       public:
         class arguments;
         class engine;
+        VanillaForwardOption(const boost::shared_ptr<QuantLib::StrikedTypePayoff>& payoff,
+                             const boost::shared_ptr<QuantLib::Exercise>& exercise, const QuantLib::Date& forwardDate,
+                             const QuantLib::Date& paymentDate)
+            : VanillaOption(payoff, exercise), forwardDate_(forwardDate), paymentDate_(paymentDate) {}
 
         VanillaForwardOption(const boost::shared_ptr<QuantLib::StrikedTypePayoff>& payoff,
             const boost::shared_ptr<QuantLib::Exercise>& exercise, const QuantLib::Date& forwardDate)
@@ -45,13 +49,15 @@ namespace QuantExt {
         
       private:
         QuantLib::Date forwardDate_;
+        QuantLib::Date paymentDate_;
     };
 
     //! %Arguments for Vanilla Forward Option calculation
     class VanillaForwardOption::arguments : public VanillaOption::arguments {
     public:
         arguments() {}
         QuantLib::Date forwardDate;
+        QuantLib::Date paymentDate;
     };
 
     inline void VanillaForwardOption::setupArguments(QuantLib::PricingEngine::arguments* args) const {
@@ -62,6 +68,7 @@ namespace QuantExt {
         QL_REQUIRE(arguments != 0, "wrong argument type");
 
         arguments->forwardDate = forwardDate_;
+        arguments->paymentDate = paymentDate_;
     }
 
     //! base class for swaption engines
diff --git a/QuantExt/qle/pricingengines/analyticeuropeanforwardengine.cpp b/QuantExt/qle/pricingengines/analyticeuropeanforwardengine.cpp
@@ -94,7 +94,11 @@ namespace QuantExt {
         DiscountFactor dividendDiscount =
             process_->dividendYield()->discount(
                                              arguments_.forwardDate);
-        DiscountFactor df = discountPtr->discount(arguments_.exercise->lastDate());
+        DiscountFactor df;
+        if (arguments_.paymentDate != Date())
+            df = discountPtr->discount(arguments_.paymentDate);
+        else
+            df = discountPtr->discount(arguments_.exercise->lastDate());
         DiscountFactor riskFreeDiscountForFwdEstimation =
             process_->riskFreeRate()->discount(arguments_.forwardDate);
         Real spot = process_->stateVariable()->value();
