Resolve QPR-12398 handle commodity indices in scripted trade with GaussianCam model

Author: mgroncki

OREData/ored/model/commodityschwartzmodelbuilder.cpp

@@ -148,13 +148,13 @@ void CommoditySchwartzModelBuilder::performCalculations() const {
             return;
         }
 
+        // use identical start values for each calibration to ensure identical results for identical baskets
+        model_->setParams(params_);
+
         LOG("CommoditySchwartzModel for name " << data_->name() << " before calibration:"
             << " sigma=" << parametrization_->sigmaParameter()
             << " kappa=" << parametrization_->kappaParameter());
 
-        // use identical start values for each calibration to ensure identical results for identical baskets
-        model_->setParams(params_);
-
         model_->calibrate(optionBasket_, *data_->optimizationMethod(), data_->endCriteria(), data_->constraint(), weights, fix);
 
         LOG("CommoditySchwartzModel for name " << data_->name() << " after calibration:"

OREData/ored/model/commodityschwartzmodeldata.hpp

@@ -110,20 +110,20 @@ class CommoditySchwartzData {
 private:
     std::string name_;
     std::string ccy_;
-    CalibrationType calibrationType_;
-    bool calibrateSigma_;
-    ParamType sigmaType_;
-    Real sigmaValue_;
-    bool calibrateKappa_;
-    ParamType kappaType_;
-    Real kappaValue_;
+    CalibrationType calibrationType_ = CalibrationType::None;
+    bool calibrateSigma_ = false;
+    ParamType sigmaType_ = ParamType::Constant;
+    Real sigmaValue_ = 0.0;
+    bool calibrateKappa_ = false;
+    ParamType kappaType_ = ParamType::Constant;
+    Real kappaValue_ = 0.0;
     std::vector<std::string> optionExpiries_;
     std::vector<std::string> optionStrikes_;
-    bool driftFreeState_;
+    bool driftFreeState_ = false;
     QuantLib::ext::shared_ptr<OptimizationMethod> optimizationMethod_;
     EndCriteria endCriteria_;
     Constraint constraint_;
-    BlackCalibrationHelper::CalibrationErrorType calibrationErrorType_;
+    BlackCalibrationHelper::CalibrationErrorType calibrationErrorType_ = BlackCalibrationHelper::RelativePriceError;
 };
 } // namespace data
 } // namespace ore

OREData/ored/model/crossassetmodelbuilder.cpp

@@ -485,6 +485,8 @@ void CrossAssetModelBuilder::buildModel() const {
         }
         auto builder = QuantLib::ext::dynamic_pointer_cast<CommoditySchwartzModelBuilder>(
             subBuilders_[CrossAssetModel::AssetType::COM][i]);
+        if (dontCalibrate_)
+            builder->freeze();
         csBuilder.push_back(builder);
         QuantLib::ext::shared_ptr<QuantExt::CommoditySchwartzParametrization> parametrization = builder->parametrization();
         comOptionBaskets_[i] = builder->optionBasket();

OREData/ored/portfolio/builders/scriptedtrade.cpp

@@ -1301,8 +1301,8 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
 
     map<CorrelationKey, Handle<Quote>> camCorrelations;
     for (auto const& c : tmpCorrelations) {
-        CorrelationFactor f_1 = parseCorrelationFactor(c.first.first);
-        CorrelationFactor f_2 = parseCorrelationFactor(c.first.second);
+        CorrelationFactor f_1 = parseCorrelationFactor(c.first.first, '#');
+        CorrelationFactor f_2 = parseCorrelationFactor(c.first.second, '#');
         // update index for JY from 0 to 1 (i.e. to the factor driving the inf index ("fx") process)
         // in all other cases the index 0 is fine, since there is only one driving factor always
         if (infModelType_ == "JY") {
@@ -1321,11 +1321,11 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
     std::set<CorrelationFactor> allCorrRiskFactors;
 
     for (auto const& m : modelIndices_)
-        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m).first));
+        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m).first, '#'));
     for (auto const& m : modelIrIndices_)
-        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m.first).first));
+        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m.first).first, '#'));
     for (auto const& m : modelInfIndices_)
-        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m.first).first));
+        allCorrRiskFactors.insert(parseCorrelationFactor(convertIndexToCamCorrelationEntry(m.first).first, '#'));
     for (auto const& ccy : modelCcys_)
         allCorrRiskFactors.insert({CrossAssetModel::AssetType::IR, ccy, 0});
 
@@ -1378,7 +1378,6 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
     std::vector<QuantLib::ext::shared_ptr<FxBsData>> fxConfigs;
     std::vector<QuantLib::ext::shared_ptr<EqBsData>> eqConfigs;
     std::vector<QuantLib::ext::shared_ptr<CommoditySchwartzData>> comConfigs;
-    // TODO: populate comConfigs
 
     // calibration expiries and terms for IR, INF, FX, EQ parametrisations (this will only work for a fixed reference
     // date, due to the way the cam builder and nested builders work, see ticket #940)
@@ -1597,8 +1596,27 @@ void ScriptedTradeEngineBuilder::buildGaussianCam(const std::string& id, const I
     std::vector<QuantLib::ext::shared_ptr<CrLgmData>> crLgmConfigs;
     std::vector<QuantLib::ext::shared_ptr<CrCirData>> crCirConfigs;
 
-    // COMM configs, not supported at this point
-    QL_REQUIRE(commIndices_.empty(), "GaussianCam model does not support commodity underlyings currently");
+    // COMM configs
+    for (auto const& comm : commIndices_) {
+        auto config = QuantLib::ext::make_shared<CommoditySchwartzData>();
+        config->currency() = getCommCcy(comm);
+        config->name() = comm.commName();
+        if (calibrationExpiries.empty() || zeroVolatility_) {
+            config->calibrationType() = CalibrationType::None;
+            config->calibrateSigma() = false;
+            config->sigmaParamType() = ParamType::Constant;
+            config->sigmaValue() = 0.0;
+        } else {
+            config->calibrationType() = CalibrationType::BestFit;
+            config->calibrateSigma() = true;
+            config->sigmaParamType() = ParamType::Constant;
+            config->sigmaValue() = 0.10; // start value for optimizer
+            config->optionExpiries() = calibrationExpiries;
+            config->optionStrikes() =
+                std::vector<std::string>(calibrationExpiries.size(), "ATMF"); // hardcoded ATMF calibration strike
+        }
+        comConfigs.push_back(config);
+    }
 
     std::string configurationInCcy = configuration(MarketContext::irCalibration);
     std::string configurationXois = configuration(MarketContext::pricing);

OREData/ored/scripting/models/gaussiancam.cpp

@@ -197,20 +197,29 @@ void GaussianCam::performCalculations() const {
     }
 
     indexPositionInProcess_.clear();
+    eqIndexInCam_.resize(indices_.size());
+    comIndexInCam_.resize(indices_.size());
+    std::fill(eqIndexInCam_.begin(), eqIndexInCam_.end(), Null<Size>());
+    std::fill(comIndexInCam_.begin(), comIndexInCam_.end(), Null<Size>());
     for (Size i = 0; i < indices_.size(); ++i) {
         if (indices_[i].isFx()) {
             // FX
             Size ccyIdx = cam_->ccyIndex(parseCurrency(indexCurrencies_[i]));
             QL_REQUIRE(ccyIdx > 0, "fx index '" << indices_[i] << "' has unexpected for ccy = base ccy");
             indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::FX, ccyIdx - 1));
-            eqIndexInCam_.push_back(Null<Size>());
         } else if (indices_[i].isEq()) {
             // EQ
             Size eqIdx = cam_->eqIndex(indices_[i].eq()->name());
             indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::EQ, eqIdx));
-            eqIndexInCam_.push_back(eqIdx);
+            eqIndexInCam_[i] = eqIdx;
+        } else if(indices_[i].isComm()) {
+            // COM
+            Size comIdx = cam_->comIndex(indices_[i].commName());
+            indexPositionInProcess_.push_back(cam_->pIdx(CrossAssetModel::AssetType::COM, comIdx));
+            comIndexInCam_[i] = comIdx;
         } else {
-            QL_FAIL("index '" << indices_[i].name() << "' expected to be FX or EQ");
+            QL_FAIL("GuassianCam::performCalculations(): index '" << indices_[i].name()
+                                                                  << "' expected to be FX, EQ, COMM");
         }
     }
 
@@ -233,7 +242,7 @@ void GaussianCam::populatePathValues(const Size nSamples, std::map<Date, std::ve
 
     // set reference date values, if there are no future simulation dates, we are done
 
-    // FX and EQ indcies
+    // FX, EQ, COMM indcies
     for (Size k = 0; k < indices_.size(); ++k) {
         paths[referenceDate_][k].setAll(process->initialValues().at(indexPositionInProcess_[k]));
     }
@@ -351,7 +360,7 @@ void GaussianCam::populatePathValues(const Size nSamples, std::map<Date, std::ve
             }
         }
 
-        // FX and EQ indcies
+        // FX, EQ, COMM indices
         std::vector<std::vector<RandomVariable*>> rvs(
             indices_.size(), std::vector<RandomVariable*>(effectiveSimulationDates_.size() - 1));
         auto date = effectiveSimulationDates_.begin();
@@ -417,8 +426,17 @@ void GaussianCam::populatePathValues(const Size nSamples, std::map<Date, std::ve
 
 RandomVariable GaussianCam::getIndexValue(const Size indexNo, const Date& d, const Date& fwd) const {
     auto res = underlyingPaths_.at(d).at(indexNo);
-    // compute forwarding factor
-    if (fwd != Null<Date>()) {
+    if (comIndexInCam_[indexNo] != Null<Size>()) {
+        // handle com (TODO: performace optimization via vectorized version of com model)
+        RandomVariable tmp(res.size());
+        for (Size i = 0; i < tmp.size(); ++i) {
+            tmp.set(i, cam_->comModel(comIndexInCam_[indexNo])
+                           ->forwardPrice(timeFromReference(d), timeFromReference(fwd != Null<Date>() ? fwd : d),
+                                          Array(1, std::log(res[i]))));
+        }
+        return tmp;
+    } else if (fwd != Null<Date>()) {
+        // handle fx, eq -> incorporate forwarding factor if applicable
         auto ccy = std::find(currencies_.begin(), currencies_.end(), indexCurrencies_[indexNo]);
         QL_REQUIRE(ccy != currencies_.end(), "GaussianCam::getIndexValue(): can not get currency for index #"
                                                  << indexNo << "(" << indices_.at(indexNo) << ")");
@@ -430,9 +448,11 @@ RandomVariable GaussianCam::getIndexValue(const Size indexNo, const Date& d, con
             res *= RandomVariable(size(), div->discount(fwd) / div->discount(d)) /
                    getDiscount(std::distance(currencies_.begin(), ccy), d, fwd,
                                cam_->eqbs(eqIndexInCam_[indexNo])->equityIrCurveToday());
+        } else if (comIndexInCam_[indexNo] != Null<Size>()) {
+
         } else {
-            QL_FAIL("GaussianGam::getIndexValue(): did not recognise  index #" << indexNo << "(" << indices_.at(indexNo)
-                                                                               << ")");
+            QL_FAIL("GaussianGam::getIndexValue(): did not recognise  index #" << indexNo << "("
+                                                                               << indices_.at(indexNo));
         }
     }
     return res;

OREData/ored/scripting/models/gaussiancam.hpp

@@ -130,6 +130,7 @@ class GaussianCam : public ModelImpl, public AmcModel {
     mutable std::vector<Size> infIndexPositionInCam_;     // maps inf index no to inf idx in cam
     mutable std::vector<Size> currencyPositionInCam_;     // maps currency no to position in cam parametrizations
     mutable std::vector<Size> eqIndexInCam_;      // maps index no to eq position in cam (or null, if not an eq index)
+    mutable std::vector<Size> comIndexInCam_;     // maps index no to com position in cam (or null, if not a com index)
     mutable bool conditionalExpectationUseIr_;    // derived from input conditionalExpectationModelState
     mutable bool conditionalExpectationUseInf_;   // derived from input conditionalExpectationModelState
     mutable bool conditionalExpectationUseAsset_; // derived from input conditionalExpectationModelState

OREData/ored/scripting/utilities.cpp

@@ -138,14 +138,16 @@ ASTNodePtr parseScript(const std::string& code) {
 std::pair<std::string, Period> convertIndexToCamCorrelationEntry(const std::string& i) {
     IndexInfo info(i);
     if (info.isIr()) {
-        return std::make_pair("IR:" + info.ir()->currency().code(), info.ir()->tenor());
+        return std::make_pair("IR#" + info.ir()->currency().code(), info.ir()->tenor());
     } else if (info.isInf()) {
-        return std::make_pair("INF:" + info.infName(), 0 * Days);
+        return std::make_pair("INF#" + info.infName(), 0 * Days);
     } else if (info.isFx()) {
-        return std::make_pair("FX:" + info.fx()->sourceCurrency().code() + info.fx()->targetCurrency().code(),
+        return std::make_pair("FX#" + info.fx()->sourceCurrency().code() + info.fx()->targetCurrency().code(),
                               0 * Days);
     } else if (info.isEq()) {
-        return std::make_pair("EQ:" + info.eq()->name(), 0 * Days);
+        return std::make_pair("EQ#" + info.eq()->name(), 0 * Days);
+    } else if (info.isComm()) {
+        return std::make_pair("COM#" + info.commName(), 0 * Days);
     } else {
         QL_FAIL("convertIndextoCamCorrelationEntry(): index '" << i << "' not recognised");
     }

OREData/ored/utilities/correlationmatrix.cpp

@@ -55,14 +55,15 @@ ostream& operator<<(ostream& out, const CorrelationFactor& f) {
     return out << f.type << ":" << f.name << ":" << f.index;
 }
 
-CorrelationFactor parseCorrelationFactor(const string& name) {
+CorrelationFactor parseCorrelationFactor(const string& name, const char separator) {
 
+    std::string sep(1, separator);
     vector<string> tokens;
-    boost::split(tokens, name, boost::is_any_of(":"));
+    boost::split(tokens, name, boost::is_any_of(sep));
 
     QL_REQUIRE(tokens.size() == 2 || tokens.size() == 3,
-               "parseCorrelationFactor(" << name
-                                         << "): expected 2 or 3 tokens separated by ':', e.g. 'IR:USD' or 'INF:UKRPI:0'");
+               "parseCorrelationFactor(" << name << "): expected 2 or 3 tokens separated by separator ('" << sep
+                                         << "'), e.g. 'IR" << sep << "USD' or 'INF" << sep << "UKRPI" << sep << "0'");
 
     return {parseCamAssetType(tokens[0]), tokens[1],
             static_cast<Size>(tokens.size() == 3 ? parseInteger(tokens[3]) : 0)};

OREData/ored/utilities/correlationmatrix.hpp

@@ -54,7 +54,7 @@ std::ostream& operator<<(std::ostream& out, const CorrelationFactor& f);
     \c type, \c name and \c index set to \c IR, \c EUR and \c 0 respectively. Note that the name is of the form 
     \c type:name and the index is always set to 0 initially. The actual index is set separately.
 */
-CorrelationFactor parseCorrelationFactor(const std::string& name);
+CorrelationFactor parseCorrelationFactor(const std::string& name, const char separator = ':');
 
 /*! The key for storing the correlation data is the pair of factors.
 */