QPR-8562 add commodity model calibration

Author: rolandlichters

Examples/Example_24/Input/simulation_wti.xml

@@ -74,15 +74,19 @@
     <CommodityModels>
       <CommoditySchwartz name="COMDTY_WTI_USD">
         <Currency>USD</Currency>
-        <CalibrationType>None</CalibrationType>
+        <CalibrationType>BestFit</CalibrationType>
         <Sigma>
-          <Calibrate>false</Calibrate>
+          <Calibrate>true</Calibrate>
           <InitialValue>0.1</InitialValue>
         </Sigma>
         <Kappa>
           <Calibrate>false</Calibrate>
           <InitialValue>0.0</InitialValue>
         </Kappa>
+        <CalibrationOptions>
+          <Expiries>1Y, 2Y, 3Y, 4Y, 5Y, 10Y</Expiries>
+          <Strikes/>
+        </CalibrationOptions>
         <DriftFreeState>true</DriftFreeState>
       </CommoditySchwartz>
     </CommodityModels>

Examples/Example_24/run.py

@@ -14,9 +14,15 @@
 oreex.run("Input/ore_wti.xml")
 oreex.get_times("Output/log.txt")
 
-oreex.print_headline("Plot exposure graph")
+oreex.print_headline("Plot Forward exposure graph")
 oreex.setup_plot("commodity_forward")
 oreex.plot("exposure_trade_CommodityForward.csv", 2, 3, 'b', "EPE")
 oreex.plot("exposure_trade_CommodityForward.csv", 2, 4, 'r', "ENE")
 oreex.decorate_plot(title="Example 24 - Simulated Commodity Forward Exposure")
 oreex.save_plot_to_file()
+
+oreex.print_headline("Plot Option exposure graph")
+oreex.setup_plot("commodity_option")
+oreex.plot("exposure_trade_CommodityOption.csv", 2, 3, 'b', "EPE")
+oreex.decorate_plot(title="Example 24 - Simulated Commodity Option Exposure")
+oreex.save_plot_to_file()

OREData/ored/model/commodityschwartzmodelbuilder.cpp

@@ -21,8 +21,10 @@
 
 #include <qle/models/commodityschwartzparametrization.hpp>
 #include <qle/models/futureoptionhelper.hpp>
+#include <qle/pricingengines/commodityschwartzfutureoptionengine.hpp>
 
 #include <ored/model/commodityschwartzmodelbuilder.hpp>
+#include <ored/model/utilities.hpp>
 #include <ored/utilities/dategrid.hpp>
 #include <ored/utilities/log.hpp>
 #include <ored/utilities/parsers.hpp>
@@ -40,7 +42,10 @@ CommoditySchwartzModelBuilder::CommoditySchwartzModelBuilder(
                          const QuantLib::Currency& baseCcy, const std::string& configuration,
                          const std::string& referenceCalibrationGrid)
     : market_(market), configuration_(configuration), data_(data), referenceCalibrationGrid_(referenceCalibrationGrid),
-      baseCcy_(baseCcy) {
+      baseCcy_(baseCcy),
+      optimizationMethod_(boost::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1E-8, 1E-8, 1E-8))),
+      endCriteria_(EndCriteria(1000, 500, 1E-8, 1E-8, 1E-8)),
+      calibrationErrorType_(BlackCalibrationHelper::RelativePriceError) {
 
     optionActive_ = std::vector<bool>(data_->optionExpiries().size(), false);
     marketObserver_ = boost::make_shared<MarketObserver>();
@@ -73,6 +78,12 @@ CommoditySchwartzModelBuilder::CommoditySchwartzModelBuilder(
     parametrization_ = boost::make_shared<QuantExt::CommoditySchwartzParametrization>(ccy, name, curve_, fxSpot_,
                                                                                       data->sigmaValue(), data->kappaValue(),
                                                                                       data->driftFreeState());
+    model_ = boost::make_shared<QuantExt::CommoditySchwartzModel>(parametrization_);
+}
+
+boost::shared_ptr<QuantExt::CommoditySchwartzModel> CommoditySchwartzModelBuilder::model() const {
+    calculate();
+    return model_;
 }
 
 Real CommoditySchwartzModelBuilder::error() const {
@@ -96,12 +107,68 @@ bool CommoditySchwartzModelBuilder::requiresRecalibration() const {
 
 void CommoditySchwartzModelBuilder::performCalculations() const {
     if (requiresRecalibration()) {
+        DLOG("COM model requires recalibration");
+
         // reset market observer updated flag
         marketObserver_->hasUpdated(true);
         // build option basket
         buildOptionBasket();
         // update vol cache
         volSurfaceChanged(true);
+
+        // attach pricing engine to helpers
+        boost::shared_ptr<QuantExt::CommoditySchwartzFutureOptionEngine> engine =
+            boost::make_shared<QuantExt::CommoditySchwartzFutureOptionEngine>(model_);
+        for (Size j = 0; j < optionBasket_.size(); j++)
+            optionBasket_[j]->setPricingEngine(engine);
+
+        QL_REQUIRE(data_->calibrationType() != CalibrationType::Bootstrap, "Bootstrap COM calibration not supported yet");
+
+        if (data_->calibrationType() == CalibrationType::None ||
+            (data_->calibrateSigma() == false && data_->calibrateKappa() == false)) {
+            LOG("COM calibration is deactivated in the CommoditySchwartzModelData for name " << data_->name());
+            return;
+        }
+
+        // check which parameters are kept fixed
+        std::vector<bool> fix(model_->parametrization()->numberOfParameters(), true);
+        Constraint constraint;
+        std::vector<Real> weights;
+        Size freeParams = 0;
+        if (data_->calibrateSigma()) {
+            fix[0] = false;
+            freeParams++;
+            LOG("CommoditySchwartzModel: calibrate sigma for name " << data_->name());
+        }
+        if (data_->calibrateKappa()) {
+            fix[1] = false;
+            freeParams++;
+            LOG("CommoditySchwartzModel: calibrate kappa for name " << data_->name());
+        }
+        if (freeParams == 0) {
+            WLOG("CommoditySchwartzModel: skip calibration for name " << data_->name() << ", no free parameters");
+            error_ = 0.0;
+            return;
+        }
+
+        LOG("CommoditySchwartzModel for name " << data_->name() << " before calibration:"
+            << " sigma=" << parametrization_->sigmaParameter()
+            << " kappa=" << parametrization_->kappaParameter());
+
+        model_->calibrate(optionBasket_, *optimizationMethod_, endCriteria_, constraint, weights, fix);
+
+        LOG("CommoditySchwartzModel for name " << data_->name() << " after calibration:"
+            << " sigma=" << parametrization_->sigmaParameter()
+            << " kappa=" << parametrization_->kappaParameter());
+
+        error_ = getCalibrationError(optionBasket_);
+        LOG("CommoditySchwartzModel calibration rmse error " << error_ << " for name " << data_->name());
+        try {
+            auto d = getCalibrationDetails(optionBasket_, parametrization_);
+            LOG(d);
+        } catch (const std::exception& e) {
+            WLOG("An error occurred: " << e.what());
+        }
     }
 }
 
@@ -152,7 +219,6 @@ bool CommoditySchwartzModelBuilder::volSurfaceChanged(const bool updateCache) co
 }
 
 void CommoditySchwartzModelBuilder::buildOptionBasket() const {
-    QL_FAIL("CommoditySchwartzModelBuilder::buildOptionBasket() not implemented yet");
 
     QL_REQUIRE(data_->optionExpiries().size() == data_->optionStrikes().size(), "Commodity option vector size mismatch");
 
@@ -178,7 +244,7 @@ void CommoditySchwartzModelBuilder::buildOptionBasket() const {
             Real strikeValue = optionStrike(j);
             Handle<Quote> volQuote(boost::make_shared<SimpleQuote>(vol_->blackVol(expiryDate, strikeValue)));
             boost::shared_ptr<QuantExt::FutureOptionHelper> helper = boost::make_shared<QuantExt::FutureOptionHelper>(
-                expiryDate, strikeValue, curve_, volQuote);
+                expiryDate, strikeValue, curve_, volQuote, calibrationErrorType_);
             optionBasket_.push_back(helper);
             helper->performCalculations();
             expiryTimes.push_back(curve_->timeFromReference(helper->option()->exercise()->date(0)));

OREData/ored/model/commodityschwartzmodelbuilder.hpp

@@ -38,7 +38,7 @@ namespace ore {
 namespace data {
 using namespace QuantLib;
 
-//! Builder for a Lognormal COM model component
+//! Builder for a COM model component
 /*!
   This class is a utility to turn a COM model component's description
   into a COM model parametrization which can be used to ultimately
@@ -67,6 +67,7 @@ class CommoditySchwartzModelBuilder : public ModelBuilder {
     //@{
     std::string name() { return data_->name(); }
     boost::shared_ptr<QuantExt::CommoditySchwartzParametrization> parametrization() const;
+    boost::shared_ptr<QuantExt::CommoditySchwartzModel> model() const;
     std::vector<boost::shared_ptr<BlackCalibrationHelper>> optionBasket() const;
     //@}
 
@@ -92,8 +93,9 @@ class CommoditySchwartzModelBuilder : public ModelBuilder {
     const QuantLib::Currency baseCcy_;
 
     // computed
-    Real error_;
+    mutable Real error_;
     mutable boost::shared_ptr<QuantExt::CommoditySchwartzParametrization> parametrization_;
+    mutable boost::shared_ptr<QuantExt::CommoditySchwartzModel> model_;
 
     // which options in data->optionExpiries() are actually in the basket?
     mutable std::vector<bool> optionActive_;
@@ -113,6 +115,12 @@ class CommoditySchwartzModelBuilder : public ModelBuilder {
 
     // market observer
     boost::shared_ptr<MarketObserver> marketObserver_;
+
+    // TODO: move to data
+    boost::shared_ptr<OptimizationMethod> optimizationMethod_;
+    EndCriteria endCriteria_;
+    BlackCalibrationHelper::CalibrationErrorType calibrationErrorType_;
+    mutable std::vector<Real> calibrationErrors_;
 };
 } // namespace data
 } // namespace ore

OREData/ored/model/commodityschwartzmodeldata.hpp

@@ -70,7 +70,7 @@ class CommoditySchwartzData {
     bool& calibrateSigma() { return calibrateSigma_; }
     ParamType& sigmaParamType() { return sigmaType_; }
     Real& sigmaValue() { return sigmaValue_; }
-    bool& calibrateKappa() { return calibrateSigma_; }
+    bool& calibrateKappa() { return calibrateKappa_; }
     ParamType& kappaParamType() { return sigmaType_; }
     Real& kappaValue() { return kappaValue_; }
     std::vector<std::string>& optionExpiries() { return optionExpiries_; }

OREData/ored/model/crossassetmodelbuilder.cpp

@@ -595,14 +595,8 @@ void CrossAssetModelBuilder::buildModel() const {
     for (Size i = 0; i < csBuilder.size(); i++) {
         DLOG("COM Calibration " << i);
         comOptionCalibrationErrors_[i] = csBuilder[i]->error();
-        // boost::shared_ptr<CommoditySchwartzData> com = config_->comConfigs()[i];
-        // if (!com->calibrateSigma() && !com->calibrateKappa()) {
-        //     DLOG("COM Calibration " << i << " skipped");
-        //     continue;
-        // }
     }
 
-
     /*************************
      * Relink LGM discount curves to curves used for INF calibration
      */

OREData/ored/model/utilities.cpp

@@ -21,6 +21,7 @@
 
 #include <qle/models/cpicapfloorhelper.hpp>
 #include <qle/models/fxeqoptionhelper.hpp>
+#include <qle/models/futureoptionhelper.hpp>
 #include <qle/models/yoycapfloorhelper.hpp>
 #include <qle/models/yoyswaphelper.hpp>
 
@@ -253,6 +254,39 @@ std::string getCalibrationDetails(const std::vector<boost::shared_ptr<BlackCalib
     return log.str();
 }
 
+std::string getCalibrationDetails(const std::vector<boost::shared_ptr<BlackCalibrationHelper>>& basket,
+                                  const boost::shared_ptr<CommoditySchwartzParametrization>& parametrization) {
+    std::ostringstream log;
+    log << std::right << std::setw(3) << "#" << std::setw(14) << "time" << std::setw(14) << "modelVol" << std::setw(14)
+        << "marketVol" << std::setw(14) << "(diff)" << std::setw(14) << "modelValue" << std::setw(14) << "marketValue"
+        << std::setw(14) << "(diff)" << std::setw(14) << "Sigma" << setw(14) << "Kappa\n";
+    Real t = 0.0;
+    Real modelSigma = parametrization->sigmaParameter();
+    Real modelKappa = parametrization->kappaParameter();
+    for (Size j = 0; j < basket.size(); j++) {
+        Real modelValue = basket[j]->modelValue();
+        Real marketValue = basket[j]->marketValue();
+        Real valueDiff = modelValue - marketValue;
+        Volatility modelVol = 0, marketVol = 0, volDiff = 0;
+        boost::shared_ptr<FutureOptionHelper> option = boost::dynamic_pointer_cast<FutureOptionHelper>(basket[j]);
+        if (option != nullptr && parametrization != nullptr) {
+            t = option->priceCurve()->timeFromReference(option->option()->exercise()->date(0));
+            //modelSigma = parametrization->sigma(t - 1E-4);
+        }
+        marketVol = basket[j]->volatility()->value();
+        modelVol = impliedVolatility(basket[j]);
+        volDiff = modelVol - marketVol;
+        log << std::setw(3) << j << std::setprecision(6) << std::setw(14) << t << std::setw(14) << modelVol
+            << std::setw(14) << marketVol << std::setw(14) << volDiff << std::setw(14) << modelValue << std::setw(14)
+            << marketValue << std::setw(14) << valueDiff << std::setw(14) << modelSigma << " " << modelKappa << "\n";
+    }
+    if (parametrization != nullptr) {
+        modelSigma = parametrization->sigma(t + 1E-4);
+    }
+    log << "t >= " << t << ": Sigma = " << modelSigma << ", Kappa = " << modelKappa << "\n";
+    return log.str();
+}
+
 std::string getCalibrationDetails(const std::vector<boost::shared_ptr<BlackCalibrationHelper>>& basket,
                                   const boost::shared_ptr<InfDkParametrization>& parametrization,
                                   bool indexIsInterpolated) {

OREData/ored/model/utilities.hpp

@@ -30,6 +30,7 @@
 #include <qle/models/infdkparametrization.hpp>
 #include <qle/models/infjyparameterization.hpp>
 #include <qle/models/irlgm1fparametrization.hpp>
+#include <qle/models/commodityschwartzparametrization.hpp>
 #include <qle/models/lgmcalibrationinfo.hpp>
 
 #include <ql/models/calibrationhelper.hpp>
@@ -81,6 +82,10 @@ std::string getCalibrationDetails(
     const boost::shared_ptr<InfDkParametrization>& parametrization = boost::shared_ptr<InfDkParametrization>(),
     bool indexIsInterpolated = true);
 
+std::string getCalibrationDetails(
+    const std::vector<boost::shared_ptr<BlackCalibrationHelper>>& basket,
+    const boost::shared_ptr<CommoditySchwartzParametrization>& parametrization = boost::shared_ptr<CommoditySchwartzParametrization>());
+
 std::string getCalibrationDetails(const std::vector<boost::shared_ptr<CalibrationHelper>>& realRateBasket,
                                   const std::vector<boost::shared_ptr<CalibrationHelper>>& indexBasket,
                                   const boost::shared_ptr<InfJyParameterization>& parameterization,

QuantExt/qle/models/commodityschwartzmodel.cpp

@@ -25,6 +25,9 @@ CommoditySchwartzModel::CommoditySchwartzModel(const boost::shared_ptr<Commodity
                                                const Discretization discretization)
     : parametrization_(parametrization), discretization_(discretization) {
     QL_REQUIRE(parametrization_ != nullptr, "CommoditySchwartzModel: parametrization is null");
+    arguments_.resize(2);
+    arguments_[0] = parametrization_->parameter(0);
+    arguments_[1] = parametrization_->parameter(1);
     stateProcess_ = boost::make_shared<CommoditySchwartzStateProcess>(parametrization_, discretization_);
 }
 

QuantExt/qle/models/commodityschwartzmodel.hpp

@@ -23,6 +23,8 @@
 
 #pragma once
 
+#include <qle/models/hwparametrization.hpp>
+#include <qle/models/irmodel.hpp>
 #include <qle/models/commodityschwartzparametrization.hpp>
 #include <qle/models/commoditymodel.hpp>
 
@@ -71,11 +73,10 @@ class CommoditySchwartzModel : public CommodityModel {
                                 const QuantLib::Handle<QuantExt::PriceTermStructure>& priceCurve
                                 = QuantLib::Handle<QuantExt::PriceTermStructure>()) const override;
 
-    // Schwartz model specific methods
-
+    //! Schwartz model specific methods
     const boost::shared_ptr<CommoditySchwartzParametrization> parametrization() const { return parametrization_; }
 
-    /*! observer and linked calibrated model interface */
+    //! observer and linked calibrated model interface
     void update() override;
     void generateArguments() override;