QPR-13640 FxEuropeanBarrierOption AMC (WIP)

Author: mgroncki

OREData/ored/CMakeLists.txt

@@ -184,6 +184,7 @@ portfolio/builders/fxdigitalbarrieroption.cpp
 portfolio/builders/fxdigitaloption.cpp
 portfolio/builders/fxdoublebarrieroption.cpp
 portfolio/builders/fxdoubletouchoption.cpp
+portfolio/builders/fxeuropeanbarrieroption.cpp
 portfolio/builders/fxforward.cpp
 portfolio/builders/fxoption.cpp
 portfolio/builders/fxtouchoption.cpp
@@ -601,6 +602,7 @@ portfolio/builders/fxdigitalbarrieroption.hpp
 portfolio/builders/fxdigitaloption.hpp
 portfolio/builders/fxdoublebarrieroption.hpp
 portfolio/builders/fxdoubletouchoption.hpp
+portfolio/builders/fxeuropeanbarrieroption.hpp
 portfolio/builders/fxforward.hpp
 portfolio/builders/fxoption.hpp
 portfolio/builders/fxtouchoption.hpp

OREData/ored/ored.hpp

@@ -200,6 +200,7 @@
 #include <ored/portfolio/builders/fxdigitaloption.hpp>
 #include <ored/portfolio/builders/fxdoublebarrieroption.hpp>
 #include <ored/portfolio/builders/fxdoubletouchoption.hpp>
+#include <ored/portfolio/builders/fxeuropeanbarrieroption.hpp>
 #include <ored/portfolio/builders/fxforward.hpp>
 #include <ored/portfolio/builders/fxoption.hpp>
 #include <ored/portfolio/builders/fxtouchoption.hpp>

OREData/ored/portfolio/builders/fxeuropeanbarrieroption.cpp

@@ -0,0 +1,77 @@
+/*
+  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.
+ */
+
+#include <ored/portfolio/builder/fxeuropeanbarrieroption.hpp>
+#include <ored/portfolio/fxeuropeanbarrieroption.hpp>
+#include <ored/portfolio/genericbarrieroption.hpp>
+#include <ored/portfolio/underlying.hpp>
+
+namespace ore {
+namespace data {
+
+QuantLib::ext::shared_ptr<ore::data::Trade>
+FxEuropeanBarrierOptionEngineBuilder::build(const Trade* trade, const QuantLib::ext::shared_ptr<EngineFactory>& engineFactory) {
+
+    auto fxEuropeanBarrierOption = dynamic_cast<const ore::data::FxEuropeanBarrierOption*>(trade);
+
+    QL_REQUIRE(
+        fxEuropeanBarrierOption != nullptr,
+        "FxEuropeanBarrierOptionEngineBuilder: internal error, could not cast to ore::data::FxEuropeanBarrierOption. Contact dev.");
+
+    auto underlying = Quantib::ext::make_shared<FXUnderlying>("FX", fxEuropeanBarrierOption->fxIndex(), 1.0);
+    
+    auto optionData = fxEuropeanBarrierOption->optionData();
+
+    std::string exerciseDate = optionData->exerciseDates().begin();
+    ScheduleDates monitoringDates("NullCalendar", "", "0D", {exerciseDate} );
+    ScheduleData barrierMonitoringDates(monitoringDates);
+
+    //! Empty transatlantic barrier
+    auto transatlanticBarrier = BarrierData();
+    //! Observation date for schedule monitoring dates only at the end
+    
+    std::string domesticCurrency = fxEuropeanBarrierOption->soldCurrency();
+
+    Date expiryDate = parseDate(exerciseDate);
+    Date paymentDate = expiryDate;
+    const QuantLib::ext::optional<OptionPaymentData>& opd = optionData.paymentData();
+    if (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 {
+            const vector<Date>& dates = opd->dates();
+            QL_REQUIRE(dates.size() == 1, "Need exactly one payment date for cash settled European option.");
+            paymentDate = dates[0];
+        }
+        QL_REQUIRE(paymentDate >= expiryDate, "Payment date must be greater than or equal to expiry date.");
+    }
+    auto qty = fxEuropeanBarrierOption->boughtAmount();
+    auto strike = fxEuropeanBarrierOption->strike();
+
+    auto barrierOption = QuantLib::ext::make_shared<GenericBarrierOption>(
+        underlying, optionData, {fxEuropeanBarrierOption->barrierData()}, barrierMonitoringDates, transatlanticBarrier,
+        domesticCurrency, to_string(paymentDate), to_string(qty), to_string(strike), "", "");
+
+    barrierOption->build(engineFactory);
+    return barrierOption;
+}
+
+} // namespace data
+} // namespace oreplus

OREData/ored/portfolio/builders/fxeuropeanbarrieroption.hpp

@@ -0,0 +1,43 @@
+/*
+  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 ored/portfolio/builder/fxeuropeanbarrieroption.hpp
+   \brief FX European Barrier Option pricing engine builder
+   \ingroup portfolio/builders
+*/
+
+#pragma once
+
+#include <ored/portfolio/enginefactory.hpp>
+#include <ored/portfolio/trade.hpp>
+#include <ql/shared_ptr.hpp>
+
+namespace ore {
+namespace data {
+
+class FxEuropeanBarrierOptionEngineBuilder : public DelegatingEngineBuilder {
+public:
+    FxEuropeanBarrierOptionEngineBuilder()
+        : DelegatingEngineBuilder("ScriptedTrade", "ScriptedTrade",
+                                  {"FxEuropeanBarrierOption"}) {}
+    QuantLib::ext::shared_ptr<ore::data::Trade> build(const Trade* trade,
+                                              const QuantLib::ext::shared_ptr<EngineFactory>& engineFactory) override;
+    std::string effectiveTradeType() const override { return "ScriptedTrade"; }
+};
+} // namespace data
+} // namespace oreplus

OREData/ored/portfolio/fxeuropeanbarrieroption.cpp

@@ -138,6 +138,7 @@ void FxEuropeanBarrierOption::build(const QuantLib::ext::shared_ptr<EngineFactor
 
     QuantLib::ext::shared_ptr<Exercise> exercise = QuantLib::ext::make_shared<EuropeanExercise>(expiryDate);
 
+    //TODO: refactor to optionData or helper function
     const QuantLib::ext::optional<OptionPaymentData>& opd = option_.paymentData();
     if (opd) {
         if (opd->rulesBased()) {

OREData/ored/portfolio/fxeuropeanbarrieroption.hpp

@@ -58,7 +58,10 @@ class FxEuropeanBarrierOption : public FxSingleAssetDerivative {
     const OptionData& option() const { return option_; }
     const BarrierData& barrier() const { return barrier_; }
     double boughtAmount() const { return boughtAmount_; }
+    const std::string boughtCurrency() const { return boughtCurrency_; }
     double soldAmount() const { return soldAmount_; }
+    const std::string soldCurrency() const { return soldCurrency_; }
+    
     const std::string& fxIndex() const { return fxIndex_; }
     Real strike() const;
     //@}