Cross Asset Model Builder. More...

#include <ored/model/crossassetmodelbuilder.hpp>

Inheritance diagram for CrossAssetModelBuilder:

Collaboration diagram for CrossAssetModelBuilder:

Public Member Functions
	CrossAssetModelBuilder (const QuantLib::ext::shared_ptr< Market > &market, const QuantLib::ext::shared_ptr< CrossAssetModelData > &config, const std::string &configurationLgmCalibration=Market::defaultConfiguration, const std::string &configurationFxCalibration=Market::defaultConfiguration, const std::string &configurationEqCalibration=Market::defaultConfiguration, const std::string &configurationInfCalibration=Market::defaultConfiguration, const std::string &configurationCrCalibration=Market::defaultConfiguration, const std::string &configurationFinalModel=Market::defaultConfiguration, const bool dontCalibrate=false, const bool continueOnError=false, const std::string &referenceCalibrationGrid_="", const SalvagingAlgorithm::Type salvaging=SalvagingAlgorithm::None, const std::string &id="unknown")

	~CrossAssetModelBuilder ()
	Default destructor. More...

Handle< QuantExt::CrossAssetModel >	model () const
	return the model More...

Inspectors
const std::vector< Real > &	swaptionCalibrationErrors ()

const std::vector< Real > &	fxOptionCalibrationErrors ()

const std::vector< Real > &	eqOptionCalibrationErrors ()

const std::vector< Real > &	inflationCalibrationErrors ()

const std::vector< Real > &	comOptionCalibrationErrors ()

Public Member Functions inherited from ModelBuilder
void	recalibrate () const

virtual void	forceRecalculate ()

virtual bool	requiresRecalibration () const=0

ModelBuilder interface
std::vector< std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > >	swaptionBaskets_

std::vector< std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > >	fxOptionBaskets_

std::vector< std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > >	eqOptionBaskets_

std::vector< std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > >	comOptionBaskets_

std::vector< Array >	optionExpiries_

std::vector< Array >	swaptionMaturities_

std::vector< Array >	fxOptionExpiries_

std::vector< Array >	eqOptionExpiries_

std::vector< Array >	comOptionExpiries_

std::vector< Real >	swaptionCalibrationErrors_

std::vector< Real >	fxOptionCalibrationErrors_

std::vector< Real >	eqOptionCalibrationErrors_

std::vector< Real >	inflationCalibrationErrors_

std::vector< Real >	comOptionCalibrationErrors_

std::map< QuantExt::CrossAssetModel::AssetType, std::map< QuantLib::Size, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > >	subBuilders_
	Store model builders for each asset under each asset type. More...

Array	params_

const QuantLib::ext::shared_ptr< ore::data::Market >	market_

const QuantLib::ext::shared_ptr< CrossAssetModelData >	config_

const std::string	configurationLgmCalibration_

const std::string	configurationFxCalibration_

const std::string	configurationEqCalibration_

const std::string	configurationInfCalibration_

const std::string	configurationCrCalibration_

const std::string	configurationComCalibration_

const std::string	configurationFinalModel_

const bool	dontCalibrate_

const bool	continueOnError_

const std::string	referenceCalibrationGrid_

const SalvagingAlgorithm::Type	salvaging_

const std::string	id_

QuantLib::ext::shared_ptr< OptimizationMethod >	optimizationMethod_

EndCriteria	endCriteria_

bool	forceCalibration_ = false

QuantLib::ext::shared_ptr< QuantExt::MarketObserver >	marketObserver_

RelinkableHandle< QuantExt::CrossAssetModel >	model_

void	forceRecalculate () override

bool	requiresRecalibration () const override

void	performCalculations () const override

void	buildModel () const

void	resetModelParams (const CrossAssetModel::AssetType t, const Size param, const Size index, const Size i) const

void	copyModelParams (const CrossAssetModel::AssetType t0, const Size param0, const Size index0, const Size i0, const CrossAssetModel::AssetType t1, const Size param1, const Size index1, const Size i1, const Real mult) const

void	calibrateInflation (const InfDkData &data, QuantLib::Size modelIdx, const std::vector< QuantLib::ext::shared_ptr< QuantLib::BlackCalibrationHelper > > &calibrationBasket, const QuantLib::ext::shared_ptr< QuantExt::InfDkParametrization > &inflationParam) const

void	calibrateInflation (const InfJyData &data, QuantLib::Size modelIdx, const QuantLib::ext::shared_ptr< InfJyBuilder > &jyBuilder, const QuantLib::ext::shared_ptr< QuantExt::InfJyParameterization > &inflationParam) const

void	setJyPricingEngine (QuantLib::Size modelIdx, const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &calibrationBasket, bool indexIsInterpolated) const

Detailed Description

Cross Asset Model Builder.

CrossAssetModelBuilder takes a market snapshot, market conventions (the latter two passed to the constructor), and a model configuration (passed to the "build" member function) to build and calibrate a cross asset model.

Definition at line 55 of file crossassetmodelbuilder.hpp.

Constructor & Destructor Documentation

◆ CrossAssetModelBuilder()

CrossAssetModelBuilder	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const QuantLib::ext::shared_ptr< CrossAssetModelData > &	config,
		const std::string &	configurationLgmCalibration = `Market::defaultConfiguration`,
		const std::string &	configurationFxCalibration = `Market::defaultConfiguration`,
		const std::string &	configurationEqCalibration = `Market::defaultConfiguration`,
		const std::string &	configurationInfCalibration = `Market::defaultConfiguration`,
		const std::string &	configurationCrCalibration = `Market::defaultConfiguration`,
		const std::string &	configurationFinalModel = `Market::defaultConfiguration`,
		const bool	dontCalibrate = `false`,
		const bool	continueOnError = `false`,
		const std::string &	referenceCalibrationGrid_ = `""`,
		const SalvagingAlgorithm::Type	salvaging = `SalvagingAlgorithm::None`,
		const std::string &	id = `"unknown"`
	)

The market for the calibration can possibly be different from the final market defining the curves attached to the marginal LGM models; for example domestic OIS curves may be used for the in currency swaption calibration while the global model is operated under FX basis consistent discounting curves relative to the collateral OIS curve.

Parameters

market	Market object
config	cam configuration
configurationLgmCalibration	Market configuration for interest rate model calibration
configurationFxCalibration	Market configuration for FX model calibration
configurationEqCalibration	Market configuration for EQ model calibration
configurationInfCalibration	Market configuration for INF model calibration
configurationCrCalibration	Market configuration for CR model calibration
configurationFinalModel	Market configuration for simulation
dontCalibrate	calibrate the model?
continueOnError	continue if bootstrap error exceeds tolerance
referenceCalibrationGrid_	reference calibration grid
salvaging	salvaging algorithm to apply to correlation matrix
id	id of the builder

Definition at line 78 of file crossassetmodelbuilder.cpp.

    : market_(market), config_(config), configurationLgmCalibration_(configurationLgmCalibration),
      configurationFxCalibration_(configurationFxCalibration), configurationEqCalibration_(configurationEqCalibration),
      configurationInfCalibration_(configurationInfCalibration),
      configurationCrCalibration_(configurationCrCalibration),
      configurationComCalibration_(Market::defaultConfiguration), configurationFinalModel_(configurationFinalModel),
      dontCalibrate_(dontCalibrate), continueOnError_(continueOnError),
      referenceCalibrationGrid_(referenceCalibrationGrid), salvaging_(salvaging), id_(id),
      optimizationMethod_(QuantLib::ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1E-8, 1E-8, 1E-8))),
      endCriteria_(EndCriteria(1000, 500, 1E-8, 1E-8, 1E-8)) {
    buildModel();
    // register with sub builders
    for (auto okv : subBuilders_)
        for (auto ikv : okv.second) {
            registerWith(ikv.second);
        }
    // register market observer with correlations
    marketObserver_ = QuantLib::ext::make_shared<MarketObserver>();
    for (auto const& c : config->correlations())
        marketObserver_->addObservable(c.second);
    // reset market observer's updated flag
    marketObserver_->hasUpdated(true);
    // register with market observer
    registerWith(marketObserver_);
}

Here is the call graph for this function:

◆ ~CrossAssetModelBuilder()

~CrossAssetModelBuilder ( )

Default destructor.

Definition at line 90 of file crossassetmodelbuilder.hpp.

90{}

Member Function Documentation

◆ model()

Handle< QuantExt::CrossAssetModel > model ( ) const

return the model

Definition at line 110 of file crossassetmodelbuilder.cpp.

                                                                    {
    calculate();
    return model_;
}

◆ swaptionCalibrationErrors()

const std::vector< Real > & swaptionCalibrationErrors ( )

Definition at line 115 of file crossassetmodelbuilder.cpp.

                                                                         {
    calculate();
    return swaptionCalibrationErrors_;
}

◆ fxOptionCalibrationErrors()

const std::vector< Real > & fxOptionCalibrationErrors ( )

Definition at line 119 of file crossassetmodelbuilder.cpp.

                                                                         {
    calculate();
    return fxOptionCalibrationErrors_;
}

◆ eqOptionCalibrationErrors()

const std::vector< Real > & eqOptionCalibrationErrors ( )

Definition at line 123 of file crossassetmodelbuilder.cpp.

                                                                         {
    calculate();
    return eqOptionCalibrationErrors_;
}

◆ inflationCalibrationErrors()

const std::vector< Real > & inflationCalibrationErrors ( )

Definition at line 127 of file crossassetmodelbuilder.cpp.

                                                                          {
    calculate();
    return inflationCalibrationErrors_;
}

◆ comOptionCalibrationErrors()

const std::vector< Real > & comOptionCalibrationErrors ( )

Definition at line 131 of file crossassetmodelbuilder.cpp.

                                                                          {
    calculate();
    return comOptionCalibrationErrors_;
}

◆ forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 792 of file crossassetmodelbuilder.cpp.

                                              {
    forceCalibration_ = true;
    ModelBuilder::forceRecalculate();
    forceCalibration_ = false;
}

Here is the call graph for this function:

◆ requiresRecalibration()

bool requiresRecalibration ( ) const

overridevirtual

Implements ModelBuilder.

Definition at line 136 of file crossassetmodelbuilder.cpp.

                                                         {
    for (auto okv : subBuilders_)
        for (auto ikv : okv.second)
            if (ikv.second->requiresRecalibration())
                return true;
 
    return marketObserver_->hasUpdated(false);
}

Here is the caller graph for this function:

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 145 of file crossassetmodelbuilder.cpp.

                                                       {
    // if any of the sub models requires a recalibration, we rebuilt the model
    // TODO we could do this more selectively
    if (!dontCalibrate_ && requiresRecalibration()) {
        // reset market observer update flag
        marketObserver_->hasUpdated(true);
        buildModel();
    }
}

Here is the call graph for this function:

◆ buildModel()

void buildModel ( ) const

private

Definition at line 194 of file crossassetmodelbuilder.cpp.

                                              {
 
    LOG("Start building CrossAssetModel");
 
    QL_REQUIRE(market_ != NULL, "CrossAssetModelBuilder: no market given");
 
    DLOG("configurations: LgmCalibration "
         << configurationLgmCalibration_ << ", FxCalibration " << configurationFxCalibration_ << ", EqCalibration "
         << configurationEqCalibration_ << ", InfCalibration " << configurationInfCalibration_ << ", CrCalibration"
         << configurationCrCalibration_ << ", ComCalibration" << configurationComCalibration_ << ", FinalModel "
         << configurationFinalModel_);
 
    if (dontCalibrate_) {
        DLOG("Calibration of the model is disabled.");
    }
 
    bool buildersAreInitialized = !subBuilders_.empty();
 
    if (!buildersAreInitialized) {
        QL_REQUIRE(config_->irConfigs().size() > 0, "missing IR configurations");
        QL_REQUIRE(config_->irConfigs().size() == config_->fxConfigs().size() + 1,
                   "FX configuration size " << config_->fxConfigs().size()
                                            << " inconsistent with IR configuration size "
                                            << config_->irConfigs().size());
 
        swaptionBaskets_.resize(config_->irConfigs().size());
        optionExpiries_.resize(config_->irConfigs().size());
        swaptionMaturities_.resize(config_->irConfigs().size());
        swaptionCalibrationErrors_.resize(config_->irConfigs().size());
        fxOptionBaskets_.resize(config_->fxConfigs().size());
        fxOptionExpiries_.resize(config_->fxConfigs().size());
        fxOptionCalibrationErrors_.resize(config_->fxConfigs().size());
        eqOptionBaskets_.resize(config_->eqConfigs().size());
        eqOptionExpiries_.resize(config_->eqConfigs().size());
        eqOptionCalibrationErrors_.resize(config_->eqConfigs().size());
        inflationCalibrationErrors_.resize(config_->infConfigs().size());
        comOptionBaskets_.resize(config_->comConfigs().size());
        comOptionExpiries_.resize(config_->comConfigs().size());
        comOptionCalibrationErrors_.resize(config_->comConfigs().size());
    }
 
    // Store information on the number of factors for each process. This is used when requesting a correlation matrix
    // from the CorrelationMatrixBuilder below.
    CorrelationMatrixBuilder::ProcessInfo processInfo;
 
    // Set the measure
    IrModel::Measure measure = IrModel::Measure::LGM;
    if (config_->measure() == "BA") {
        measure = IrModel::Measure::BA;
        DLOG("Setting measure to BA");
    } else if (config_->measure() == "LGM") {
        measure = IrModel::Measure::LGM;
        DLOG("Setting measure to LGM");
    } else if (config_->measure() == "") {
        DLOG("Defaulting to LGM measure");
    } else {
        QL_FAIL("Measure " << config_->measure() << " not recognized");
    }
 
    /*******************************************************
     * Build the IR parametrizations and calibration baskets
     */
    std::vector<QuantLib::ext::shared_ptr<QuantExt::Parametrization>> irParametrizations;
    std::vector<RelinkableHandle<YieldTermStructure>> irDiscountCurves;
    std::vector<std::string> currencies, regions, crNames, eqNames, infIndices, comNames;
    std::vector<QuantLib::ext::shared_ptr<LgmBuilder>> lgmBuilder;
    std::vector<QuantLib::ext::shared_ptr<HwBuilder>> hwBuilder;
    std::vector<QuantLib::ext::shared_ptr<FxBsBuilder>> fxBuilder;
    std::vector<QuantLib::ext::shared_ptr<EqBsBuilder>> eqBuilder;
    std::vector<QuantLib::ext::shared_ptr<CommoditySchwartzModelBuilder>> csBuilder;
 
    std::set<std::string> recalibratedCurrencies;
    for (Size i = 0; i < config_->irConfigs().size(); i++) {
        auto irConfig = config_->irConfigs()[i];
        DLOG("IR Parametrization " << i << " qualifier " << irConfig->qualifier());
 
        if (auto ir = QuantLib::ext::dynamic_pointer_cast<IrLgmData>(irConfig)) {
            if (!buildersAreInitialized) {
                subBuilders_[CrossAssetModel::AssetType::IR][i] = QuantLib::ext::make_shared<LgmBuilder>(
                    market_, ir, configurationLgmCalibration_, config_->bootstrapTolerance(), continueOnError_,
                    referenceCalibrationGrid_, false, id_);
            }
            auto builder = QuantLib::ext::dynamic_pointer_cast<LgmBuilder>(subBuilders_[CrossAssetModel::AssetType::IR][i]);
            lgmBuilder.push_back(builder);
            if (dontCalibrate_) {
                builder->freeze();
            }
            if (builder->requiresRecalibration())
                recalibratedCurrencies.insert(builder->parametrization()->currency().code());
            auto parametrization = builder->parametrization();
            swaptionBaskets_[i] = builder->swaptionBasket();
            QL_REQUIRE(std::find(currencies.begin(), currencies.end(), parametrization->currency().code()) ==
                           currencies.end(),
                       "Duplicate IR parameterization for currency "
                           << parametrization->currency().code()
                           << " - are there maybe two indices with the same currency in CrossAssetModelData?");
            currencies.push_back(parametrization->currency().code());
            irParametrizations.push_back(parametrization);
            irDiscountCurves.push_back(builder->discountCurve());
            processInfo[CrossAssetModel::AssetType::IR].emplace_back(ir->ccy(), 1);
        } else if (auto ir = QuantLib::ext::dynamic_pointer_cast<HwModelData>(irConfig)) {
            bool evaluateBankAccount = true; // updated in cross asset model for non-base ccys
            bool setCalibrationInfo = false;
            HwModel::Discretization discr = HwModel::Discretization::Euler;
            if (!buildersAreInitialized) {
                subBuilders_[CrossAssetModel::AssetType::IR][i] = QuantLib::ext::make_shared<HwBuilder>(
                    market_, ir, measure, discr, evaluateBankAccount, configurationLgmCalibration_,
                    config_->bootstrapTolerance(), continueOnError_, referenceCalibrationGrid_, setCalibrationInfo);
            }
            auto builder = QuantLib::ext::dynamic_pointer_cast<HwBuilder>(subBuilders_[CrossAssetModel::AssetType::IR][i]);
            hwBuilder.push_back(builder);
            if (builder->requiresRecalibration())
                recalibratedCurrencies.insert(builder->parametrization()->currency().code());
            auto parametrization = builder->parametrization();
            if (dontCalibrate_)
                builder->freeze();
            swaptionBaskets_[i] = builder->swaptionBasket();
            QL_REQUIRE(std::find(currencies.begin(), currencies.end(), parametrization->currency().code()) ==
                           currencies.end(),
                       "Duplicate IR parameterization for currency "
                           << parametrization->currency().code()
                           << " - are there maybe two indices with the same currency in CrossAssetModelData?");
            currencies.push_back(parametrization->currency().code());
            irParametrizations.push_back(parametrization);
            irDiscountCurves.push_back(builder->discountCurve());
            processInfo[CrossAssetModel::AssetType::IR].emplace_back(ir->ccy(), parametrization->m());
        }
    }
 
    QL_REQUIRE(irParametrizations.size() > 0, "missing IR parametrizations");
 
    QuantLib::Currency domesticCcy = irParametrizations[0]->currency();
 
    /*******************************************************
     * Build the FX parametrizations and calibration baskets
     */
    std::vector<QuantLib::ext::shared_ptr<QuantExt::FxBsParametrization>> fxParametrizations;
    for (Size i = 0; i < config_->fxConfigs().size(); i++) {
        DLOG("FX Parametrization " << i);
        QuantLib::ext::shared_ptr<FxBsData> fx = config_->fxConfigs()[i];
        QuantLib::Currency ccy = ore::data::parseCurrency(fx->foreignCcy());
        QuantLib::Currency domCcy = ore::data::parseCurrency(fx->domesticCcy());
 
        QL_REQUIRE(ccy.code() == irParametrizations[i + 1]->currency().code(),
                   "FX parametrization currency[" << i << "]=" << ccy << " does not match IR currency[" << i + 1
                                                  << "]=" << irParametrizations[i + 1]->currency().code());
 
        QL_REQUIRE(domCcy == domesticCcy, "FX parametrization [" << i << "]=" << ccy << "/" << domCcy
                                                                 << " does not match domestic ccy " << domesticCcy);
 
        if (!buildersAreInitialized) {
            subBuilders_[CrossAssetModel::AssetType::FX][i] =
                QuantLib::ext::make_shared<FxBsBuilder>(market_, fx, configurationFxCalibration_, referenceCalibrationGrid_);
        }
        auto builder = QuantLib::ext::dynamic_pointer_cast<FxBsBuilder>(subBuilders_[CrossAssetModel::AssetType::FX][i]);
        fxBuilder.push_back(builder);
 
        QuantLib::ext::shared_ptr<QuantExt::FxBsParametrization> parametrization = builder->parametrization();
 
        fxOptionBaskets_[i] = builder->optionBasket();
        fxParametrizations.push_back(parametrization);
        processInfo[CrossAssetModel::AssetType::FX].emplace_back(ccy.code() + domCcy.code(), 1);
    }
 
    /*******************************************************
     * Build the EQ parametrizations and calibration baskets
     */
    std::vector<QuantLib::ext::shared_ptr<QuantExt::EqBsParametrization>> eqParametrizations;
    for (Size i = 0; i < config_->eqConfigs().size(); i++) {
        DLOG("EQ Parametrization " << i);
        QuantLib::ext::shared_ptr<EqBsData> eq = config_->eqConfigs()[i];
        string eqName = eq->eqName();
        QuantLib::Currency eqCcy = ore::data::parseCurrency(eq->currency());
        QL_REQUIRE(std::find(currencies.begin(), currencies.end(), eqCcy.code()) != currencies.end(),
                   "Currency (" << eqCcy << ") for equity " << eqName << " not covered by CrossAssetModelData");
        if (!buildersAreInitialized) {
            subBuilders_[CrossAssetModel::AssetType::EQ][i] = QuantLib::ext::make_shared<EqBsBuilder>(
                market_, eq, domesticCcy, configurationEqCalibration_, referenceCalibrationGrid_);
        }
        QuantLib::ext::shared_ptr<EqBsBuilder> builder =
            QuantLib::ext::dynamic_pointer_cast<EqBsBuilder>(subBuilders_[CrossAssetModel::AssetType::EQ][i]);
        eqBuilder.push_back(builder);
        QuantLib::ext::shared_ptr<QuantExt::EqBsParametrization> parametrization = builder->parametrization();
        eqOptionBaskets_[i] = builder->optionBasket();
        eqParametrizations.push_back(parametrization);
        eqNames.push_back(eqName);
        processInfo[CrossAssetModel::AssetType::EQ].emplace_back(eqName, 1);
    }
 
    /*******************************************************
     * Build the INF parametrizations and calibration baskets
     */
    vector<QuantLib::ext::shared_ptr<Parametrization>> infParameterizations;
    for (Size i = 0; i < config_->infConfigs().size(); i++) {
        QuantLib::ext::shared_ptr<InflationModelData> imData = config_->infConfigs()[i];
        DLOG("Inflation parameterisation (" << i << ") for index " << imData->index());
        if (auto dkData = QuantLib::ext::dynamic_pointer_cast<InfDkData>(imData)) {
            if (!buildersAreInitialized) {
                subBuilders_[CrossAssetModel::AssetType::INF][i] = QuantLib::ext::make_shared<InfDkBuilder>(
                    market_, dkData, configurationInfCalibration_, referenceCalibrationGrid_, dontCalibrate_);
            }
            QuantLib::ext::shared_ptr<InfDkBuilder> builder =
                QuantLib::ext::dynamic_pointer_cast<InfDkBuilder>(subBuilders_[CrossAssetModel::AssetType::INF][i]);
            infParameterizations.push_back(builder->parametrization());
            processInfo[CrossAssetModel::AssetType::INF].emplace_back(dkData->index(), 1);
        } else if (auto jyData = QuantLib::ext::dynamic_pointer_cast<InfJyData>(imData)) {
            if (!buildersAreInitialized) {
                // for linked real rate params we have to resize the real rate params here again, because their time grid
                // might have been overwritten in the ir calibration step
                if (jyData->linkRealRateParamsToNominalRateParams()) {
                    Size ccyIndex = std::distance(currencies.begin(),
                                                  std::find(currencies.begin(), currencies.end(), jyData->currency()));
                    VolatilityParameter rrVol = jyData->realRateVolatility();
                    ReversionParameter rrRev = jyData->realRateReversion();
                    rrVol.setCalibrate(false);
                    rrRev.setCalibrate(false);
                    auto volTimes = irParametrizations[ccyIndex]->parameterTimes(0);
                    auto volValues = irParametrizations[ccyIndex]->parameterValues(0);
                    auto revTimes = irParametrizations[ccyIndex]->parameterTimes(1);
                    auto revValues = irParametrizations[ccyIndex]->parameterValues(1);
                    rrVol.setTimes(std::vector<Real>(volTimes.begin(), volTimes.end()));
                    rrRev.setTimes(std::vector<Real>(revTimes.begin(), revTimes.end()));
                    rrVol.setValues(std::vector<Real>(volValues.begin(), volValues.end()));
                    rrRev.setValues(std::vector<Real>(revValues.begin(), revValues.end()));
                    rrVol. mult(jyData->linkedRealRateVolatilityScaling());
                    jyData->setRealRateReversion(rrRev);
                    jyData->setRealRateVolatility(rrVol);
                }
                subBuilders_[CrossAssetModel::AssetType::INF][i] = QuantLib::ext::make_shared<InfJyBuilder>(
                    market_, jyData, configurationInfCalibration_, referenceCalibrationGrid_, dontCalibrate_);
            }
            auto builder = QuantLib::ext::dynamic_pointer_cast<InfJyBuilder>(subBuilders_[CrossAssetModel::AssetType::INF][i]);
            infParameterizations.push_back(builder->parameterization());
            processInfo[CrossAssetModel::AssetType::INF].emplace_back(jyData->index(), 2);
        } else {
            QL_FAIL("CrossAssetModelBuilder expects either DK or JY inflation model data.");
        }
        infIndices.push_back(imData->index());
    }
 
    /*******************************************************
     * Build the CR parametrizations and calibration baskets
     */
    // LGM (if any)
    std::vector<QuantLib::ext::shared_ptr<QuantExt::CrLgm1fParametrization>> crLgmParametrizations;
    for (Size i = 0; i < config_->crLgmConfigs().size(); ++i) {
        LOG("CR LGM Parametrization " << i);
        QuantLib::ext::shared_ptr<CrLgmData> cr = config_->crLgmConfigs()[i];
        string crName = cr->name();
        if (!buildersAreInitialized) {
            subBuilders_[CrossAssetModel::AssetType::CR][i] =
                QuantLib::ext::make_shared<CrLgmBuilder>(market_, cr, configurationCrCalibration_);
        }
        auto builder = QuantLib::ext::dynamic_pointer_cast<CrLgmBuilder>(subBuilders_[CrossAssetModel::AssetType::CR][i]);
        QuantLib::ext::shared_ptr<QuantExt::CrLgm1fParametrization> parametrization = builder->parametrization();
        crLgmParametrizations.push_back(parametrization);
        crNames.push_back(crName);
        processInfo[CrossAssetModel::AssetType::CR].emplace_back(crName, 1);
    }
 
    // CIR (if any)
    std::vector<QuantLib::ext::shared_ptr<QuantExt::CrCirppParametrization>> crCirParametrizations;
    for (Size i = 0; i < config_->crCirConfigs().size(); ++i) {
        LOG("CR CIR Parametrization " << i);
        QuantLib::ext::shared_ptr<CrCirData> cr = config_->crCirConfigs()[i];
        string crName = cr->name();
        if (!buildersAreInitialized) {
            subBuilders_[CrossAssetModel::AssetType::CR][i] =
                QuantLib::ext::make_shared<CrCirBuilder>(market_, cr, configurationCrCalibration_);
        }
        auto builder = QuantLib::ext::dynamic_pointer_cast<CrCirBuilder>(subBuilders_[CrossAssetModel::AssetType::CR][i]);
        QuantLib::ext::shared_ptr<QuantExt::CrCirppParametrization> parametrization = builder->parametrization();
        crCirParametrizations.push_back(parametrization);
        crNames.push_back(crName);
        processInfo[CrossAssetModel::AssetType::CR].emplace_back(crName, 1);
    }
 
    /*******************************************************
     * Build the COM parametrizations and calibration baskets
     */
    std::vector<QuantLib::ext::shared_ptr<QuantExt::CommoditySchwartzParametrization>> comParametrizations;
    for (Size i = 0; i < config_->comConfigs().size(); i++) {
        DLOG("COM Parametrization " << i);
        QuantLib::ext::shared_ptr<CommoditySchwartzData> com = config_->comConfigs()[i];
        string comName = com->name();
        QuantLib::Currency comCcy = ore::data::parseCurrency(com->currency());
        QL_REQUIRE(std::find(currencies.begin(), currencies.end(), comCcy.code()) != currencies.end(),
                   "Currency (" << comCcy << ") for commodity " << comName << " not covered by CrossAssetModelData");
        if (!buildersAreInitialized) {
            subBuilders_[CrossAssetModel::AssetType::COM][i] = QuantLib::ext::make_shared<CommoditySchwartzModelBuilder>(
                market_, com, domesticCcy, configurationComCalibration_, referenceCalibrationGrid_);
        }
        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();
        comParametrizations.push_back(parametrization);
        comNames.push_back(comName);
        processInfo[CrossAssetModel::AssetType::COM].emplace_back(comName, 1);
    }
 
    /*******************************************************
     * Build the CrState parametrizations
     */
    std::vector<QuantLib::ext::shared_ptr<QuantExt::CrStateParametrization>> crStateParametrizations;
    for (Size i = 0; i < config_->numberOfCreditStates(); i++) {
        DLOG("CrState Parametrization " << i);
        crStateParametrizations.push_back(QuantLib::ext::make_shared<QuantExt::CrStateParametrization>(i));
        processInfo[CrossAssetModel::AssetType::CrState].emplace_back(std::to_string(i), 1);
    }
 
    std::vector<QuantLib::ext::shared_ptr<QuantExt::Parametrization>> parametrizations;
    for (Size i = 0; i < irParametrizations.size(); i++)
        parametrizations.push_back(irParametrizations[i]);
    for (Size i = 0; i < fxParametrizations.size(); i++)
        parametrizations.push_back(fxParametrizations[i]);
    for (Size i = 0; i < eqParametrizations.size(); i++)
        parametrizations.push_back(eqParametrizations[i]);
    parametrizations.insert(parametrizations.end(), infParameterizations.begin(), infParameterizations.end());
    for (Size i = 0; i < crLgmParametrizations.size(); i++)
        parametrizations.push_back(crLgmParametrizations[i]);
    for (Size i = 0; i < crCirParametrizations.size(); i++)
        parametrizations.push_back(crCirParametrizations[i]);
    for (Size i = 0; i < comParametrizations.size(); i++)
        parametrizations.push_back(comParametrizations[i]);
    for (Size i = 0; i < crStateParametrizations.size(); i++)
        parametrizations.push_back(crStateParametrizations[i]);
 
    QL_REQUIRE(fxParametrizations.size() == irParametrizations.size() - 1, "mismatch in IR/FX parametrization sizes");
 
    /******************************
     * Build the correlation matrix
     */
    DLOG("CrossAssetModelBuilder: adding correlations.");
    CorrelationMatrixBuilder cmb;
 
    for (auto it = config_->correlations().begin(); it != config_->correlations().end(); it++) {
        cmb.addCorrelation(it->first.first, it->first.second, it->second);
    }
 
    Matrix corrMatrix = cmb.correlationMatrix(processInfo);
 
    TLOG("CAM correlation matrix:");
    TLOGGERSTREAM(corrMatrix);
 
    /*****************************
     * Build the cross asset model
     */
 
    model_.linkTo(QuantLib::ext::make_shared<QuantExt::CrossAssetModel>(parametrizations, corrMatrix, salvaging_, measure,
                                                                config_->discretization()));
 
    /* Store initial params to ensure identical start values when recalibrating a component.
       This is only used for fx, eq, inf, cr, com, for ir this is handled in LgmBuilder directly.
       Therefore it does not matter that the IR parameters are calibrated at this point already. */
 
    if (!buildersAreInitialized) {
        params_ = model_->params();
    }
 
    /*************************
     * Calibrate IR components
     */
 
    for (Size i = 0; i < lgmBuilder.size(); i++) {
        DLOG("IR Calibration " << i);
        swaptionCalibrationErrors_[i] = lgmBuilder[i]->error();
    }
 
    for (Size i = 0; i < hwBuilder.size(); i++) {
        DLOG("IR Calibration " << i);
        swaptionCalibrationErrors_[i] = hwBuilder[i]->error();
    }
 
    /*************************
     * Relink LGM discount curves to curves used for FX calibration
     */
 
    for (Size i = 0; i < irParametrizations.size(); i++) {
        auto p = irParametrizations[i];
        irDiscountCurves[i].linkTo(*market_->discountCurve(p->currency().code(), configurationFxCalibration_));
        DLOG("Relinked discounting curve for " << p->currency().code() << " for FX calibration");
    }
 
    /*************************
     * Calibrate FX components
     */
 
    for (Size i = 0; i < fxParametrizations.size(); i++) {
        QuantLib::ext::shared_ptr<FxBsData> fx = config_->fxConfigs()[i];
 
        if (fx->calibrationType() == CalibrationType::None || !fx->calibrateSigma()) {
            DLOG("FX Calibration " << i << " skipped");
            continue;
        }
 
        if (!fxBuilder[i]->requiresRecalibration() &&
            recalibratedCurrencies.find(fx->foreignCcy()) == recalibratedCurrencies.end() &&
            recalibratedCurrencies.find(fx->domesticCcy()) == recalibratedCurrencies.end()) {
            DLOG("FX Calibration "
                 << i << " skipped, since neither fx builder nor ir models in dom / for ccy were recalibrated.");
            continue;
        }
 
        DLOG("FX Calibration " << i);
 
        // attach pricing engines to helpers
        QuantLib::ext::shared_ptr<QuantExt::AnalyticCcLgmFxOptionEngine> engine =
            QuantLib::ext::make_shared<QuantExt::AnalyticCcLgmFxOptionEngine>(*model_, i);
        // enable caching for calibration
        // TODO: review this
        engine->cache(true);
        for (Size j = 0; j < fxOptionBaskets_[i].size(); j++)
            fxOptionBaskets_[i][j]->setPricingEngine(engine);
 
        if (!dontCalibrate_) {
 
            // reset to initial params to ensure identical calibration outcomes for identical baskets
            resetModelParams(CrossAssetModel::AssetType::FX, 0, i, Null<Size>());
 
            if (fx->calibrationType() == CalibrationType::Bootstrap && fx->sigmaParamType() == ParamType::Piecewise)
                model_->calibrateBsVolatilitiesIterative(CrossAssetModel::AssetType::FX, i, fxOptionBaskets_[i],
                                                         *optimizationMethod_, endCriteria_);
            else
                model_->calibrateBsVolatilitiesGlobal(CrossAssetModel::AssetType::FX, i, fxOptionBaskets_[i],
                                                      *optimizationMethod_, endCriteria_);
 
            DLOG("FX " << fx->foreignCcy() << " calibration errors:");
            fxOptionCalibrationErrors_[i] = getCalibrationError(fxOptionBaskets_[i]);
            if (fx->calibrationType() == CalibrationType::Bootstrap) {
                if (fabs(fxOptionCalibrationErrors_[i]) < config_->bootstrapTolerance()) {
                    TLOGGERSTREAM("Calibration details:");
                    TLOGGERSTREAM(
                        getCalibrationDetails(fxOptionBaskets_[i], fxParametrizations[i], irParametrizations[0]));
                    TLOGGERSTREAM("rmse = " << fxOptionCalibrationErrors_[i]);
                } else {
                    std::string exceptionMessage = "FX BS " + std::to_string(i) + " calibration error " +
                                                   std::to_string(fxOptionCalibrationErrors_[i]) +
                                                   " exceeds tolerance " +
                                                   std::to_string(config_->bootstrapTolerance());
                    StructuredModelWarningMessage("Failed to calibrate FX BS Model", exceptionMessage, id_).log();
                    WLOGGERSTREAM("Calibration details:");
                    WLOGGERSTREAM(
                        getCalibrationDetails(fxOptionBaskets_[i], fxParametrizations[i], irParametrizations[0]));
                    WLOGGERSTREAM("rmse = " << fxOptionCalibrationErrors_[i]);
                    if (!continueOnError_)
                        QL_FAIL(exceptionMessage);
                }
            }
        }
        fxBuilder[i]->setCalibrationDone();
    }
 
    /*************************
     * Relink LGM discount curves to curves used for EQ calibration
     */
 
    for (Size i = 0; i < irParametrizations.size(); i++) {
        auto p = irParametrizations[i];
        irDiscountCurves[i].linkTo(*market_->discountCurve(p->currency().code(), configurationEqCalibration_));
        DLOG("Relinked discounting curve for " << p->currency().code() << " for EQ calibration");
    }
 
    /*************************
     * Calibrate EQ components
     */
 
    for (Size i = 0; i < eqParametrizations.size(); i++) {
        QuantLib::ext::shared_ptr<EqBsData> eq = config_->eqConfigs()[i];
        if (!eq->calibrateSigma()) {
            DLOG("EQ Calibration " << i << " skipped");
            continue;
        }
 
        if (!eqBuilder[i]->requiresRecalibration() &&
            recalibratedCurrencies.find(eq->currency()) == recalibratedCurrencies.end()) {
            DLOG("EQ Calibration " << i
                                   << " skipped, since neither eq builder nor ir model in eq ccy were recalibrated.");
            continue;
        }
 
        DLOG("EQ Calibration " << i);
        // attach pricing engines to helpers
        Currency eqCcy = eqParametrizations[i]->currency();
        Size eqCcyIdx = model_->ccyIndex(eqCcy);
        QuantLib::ext::shared_ptr<QuantExt::AnalyticXAssetLgmEquityOptionEngine> engine =
            QuantLib::ext::make_shared<QuantExt::AnalyticXAssetLgmEquityOptionEngine>(*model_, i, eqCcyIdx);
        for (Size j = 0; j < eqOptionBaskets_[i].size(); j++)
            eqOptionBaskets_[i][j]->setPricingEngine(engine);
 
        if (!dontCalibrate_) {
 
            // reset to initial params to ensure identical calibration outcomes for identical baskets
            resetModelParams(CrossAssetModel::AssetType::EQ, 0, i, Null<Size>());
 
            if (eq->calibrationType() == CalibrationType::Bootstrap && eq->sigmaParamType() == ParamType::Piecewise)
                model_->calibrateBsVolatilitiesIterative(CrossAssetModel::AssetType::EQ, i, eqOptionBaskets_[i],
                                                         *optimizationMethod_, endCriteria_);
            else
                model_->calibrateBsVolatilitiesGlobal(CrossAssetModel::AssetType::EQ, i, eqOptionBaskets_[i],
                                                      *optimizationMethod_, endCriteria_);
            DLOG("EQ " << eq->eqName() << " calibration errors:");
            eqOptionCalibrationErrors_[i] = getCalibrationError(eqOptionBaskets_[i]);
            if (eq->calibrationType() == CalibrationType::Bootstrap) {
                if (fabs(eqOptionCalibrationErrors_[i]) < config_->bootstrapTolerance()) {
                    TLOGGERSTREAM("Calibration details:");
                    TLOGGERSTREAM(
                        getCalibrationDetails(eqOptionBaskets_[i], eqParametrizations[i], irParametrizations[0]));
                    TLOGGERSTREAM("rmse = " << eqOptionCalibrationErrors_[i]);
                } else {
                    std::string exceptionMessage = "EQ BS " + std::to_string(i) + " calibration error " +
                                                   std::to_string(eqOptionCalibrationErrors_[i]) +
                                                   " exceeds tolerance " +
                                                   std::to_string(config_->bootstrapTolerance());
                    StructuredModelWarningMessage("Failed to calibrate EQ BS Model", exceptionMessage, id_).log();
                    WLOGGERSTREAM("Calibration details:");
                    WLOGGERSTREAM(
                        getCalibrationDetails(eqOptionBaskets_[i], eqParametrizations[i], irParametrizations[0]));
                    WLOGGERSTREAM("rmse = " << eqOptionCalibrationErrors_[i]);
                    if (!continueOnError_)
                        QL_FAIL(exceptionMessage);
                }
            }
        }
        eqBuilder[i]->setCalibrationDone();
    }
 
    /*************************
     * Calibrate COM components
     */
 
    for (Size i = 0; i < csBuilder.size(); i++) {
        DLOG("COM Calibration " << i);
        comOptionCalibrationErrors_[i] = csBuilder[i]->error();
    }
 
    /*************************
     * Relink LGM discount curves to curves used for INF calibration
     */
 
    for (Size i = 0; i < irParametrizations.size(); i++) {
        auto p = irParametrizations[i];
        irDiscountCurves[i].linkTo(*market_->discountCurve(p->currency().code(), configurationInfCalibration_));
        DLOG("Relinked discounting curve for " << p->currency().code() << " for INF calibration");
    }
 
    // Calibrate INF components
    for (Size i = 0; i < infParameterizations.size(); i++) {
        QuantLib::ext::shared_ptr<InflationModelData> imData = config_->infConfigs()[i];
        if (auto dkData = QuantLib::ext::dynamic_pointer_cast<InfDkData>(imData)) {
            auto dkParam = QuantLib::ext::dynamic_pointer_cast<InfDkParametrization>(infParameterizations[i]);
            QL_REQUIRE(dkParam, "Expected DK model data to have given a DK parameterisation.");
            const auto& builder = subBuilders_.at(CrossAssetModel::AssetType::INF).at(i);
            const auto& dkBuilder = QuantLib::ext::dynamic_pointer_cast<InfDkBuilder>(builder);
            if (!dkBuilder->requiresRecalibration() &&
                recalibratedCurrencies.find(infParameterizations[i]->currency().code()) ==
                    recalibratedCurrencies.end()) {
                DLOG("Skipping inf dk calibration "
                     << i << " since neither inf builder nor ir model in inf ccy were recalibrated.");
                continue;
            }
            calibrateInflation(*dkData, i, dkBuilder->optionBasket(), dkParam);
            dkBuilder->setCalibrationDone();
        } else if (auto jyData = QuantLib::ext::dynamic_pointer_cast<InfJyData>(imData)) {
            auto jyParam = QuantLib::ext::dynamic_pointer_cast<InfJyParameterization>(infParameterizations[i]);
            QL_REQUIRE(jyParam, "Expected JY model data to have given a JY parameterisation.");
            const auto& builder = subBuilders_.at(CrossAssetModel::AssetType::INF).at(i);
            const auto& jyBuilder = QuantLib::ext::dynamic_pointer_cast<InfJyBuilder>(builder);
            if (!jyBuilder->requiresRecalibration() &&
                recalibratedCurrencies.find(infParameterizations[i]->currency().code()) ==
                    recalibratedCurrencies.end()) {
                DLOG("Skipping inf jy calibration "
                     << i << " since neither inf builder nor ir model in inf ccy were recalibrated.");
                continue;
            }
            calibrateInflation(*jyData, i, jyBuilder, jyParam);
            jyBuilder->setCalibrationDone();
        } else {
            QL_FAIL("CrossAssetModelBuilder expects either DK or JY inflation model data.");
        }
    }
 
    /*************************
     * Relink LGM discount curves to final model curves
     */
 
    for (Size i = 0; i < irParametrizations.size(); i++) {
        auto p = irParametrizations[i];
        irDiscountCurves[i].linkTo(*market_->discountCurve(p->currency().code(), configurationFinalModel_));
        DLOG("Relinked discounting curve for " << p->currency().code() << " as final model curves");
    }
 
    DLOG("Building CrossAssetModel done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetModelParams()

void resetModelParams	(	const CrossAssetModel::AssetType	t,
		const Size	param,
		const Size	index,
		const Size	i
	)		const

private

Definition at line 155 of file crossassetmodelbuilder.cpp.

                                                                  {
    auto mp = model_->MoveParameter(t, param, index, i);
    for (Size idx = 0; idx < mp.size(); ++idx) {
        if (!mp[idx]) {
            model_->setParam(idx, params_[idx]);
        }
    }
}

Here is the caller graph for this function:

◆ copyModelParams()

void copyModelParams	(	const CrossAssetModel::AssetType	t0,
		const Size	param0,
		const Size	index0,
		const Size	i0,
		const CrossAssetModel::AssetType	t1,
		const Size	param1,
		const Size	index1,
		const Size	i1,
		const Real	mult
	)		const

private

Definition at line 165 of file crossassetmodelbuilder.cpp.

                                                                                                      {
    auto mp0 = model_->MoveParameter(t0, param0, index0, i0);
    auto mp1 = model_->MoveParameter(t1, param1, index1, i1);
    auto s0 = 0, s1 = 0;
    for (Size i = 0; i < mp0.size(); ++i)
        if (!mp0[i])
            s0++;
    for (Size i = 0; i < mp1.size(); ++i)
        if (!mp1[i])
            s1++;
    QL_REQUIRE(s0 == s1, "CrossAssetModelBuilder::copyModelParams(): source range size ("
                             << s0 << ") does not match target range size (" << s1 << ") when copying (" << t0 << ","
                             << param0 << "," << index0 << "," << i0 << ") -> (" << t1 << "," << param1 << "," << index1
                             << "," << i1 << ")");
    std::vector<Real> sourceValues(s0);
    for (Size idx0 = 0, count = 0; idx0 < mp0.size(); ++idx0) {
        if (!mp0[idx0]) {
            sourceValues[count++] = params_[idx0];
        }
    }
    for (Size idx1 = 0, count = 0; idx1 < mp1.size(); ++idx1) {
        if (!mp1[idx1]) {
            model_->setParam(idx1, sourceValues[count++] * mult);
        }
    }
}

◆ calibrateInflation() [1/2]

void calibrateInflation	(	const InfDkData &	data,
		QuantLib::Size	modelIdx,
		const std::vector< QuantLib::ext::shared_ptr< QuantLib::BlackCalibrationHelper > > &	calibrationBasket,
		const QuantLib::ext::shared_ptr< QuantExt::InfDkParametrization > &	inflationParam
	)		const

private

Here is the caller graph for this function:

◆ calibrateInflation() [2/2]

void calibrateInflation	(	const InfJyData &	data,
		QuantLib::Size	modelIdx,
		const QuantLib::ext::shared_ptr< InfJyBuilder > &	jyBuilder,
		const QuantLib::ext::shared_ptr< QuantExt::InfJyParameterization > &	inflationParam
	)		const

private

◆ setJyPricingEngine()

void setJyPricingEngine	(	QuantLib::Size	modelIdx,
		const std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > > &	calibrationBasket,
		bool	indexIsInterpolated
	)		const

private

Definition at line 1036 of file crossassetmodelbuilder.cpp.

                                                                                {
 
    DLOG("Start setting pricing engines on JY calibration instruments.");
 
    // JY supports three types of calibration helpers. Generally, all of the calibration instruments in a basket will
    // be of the same type but we support all three here.
    QuantLib::ext::shared_ptr<PricingEngine> cpiCapFloorEngine;
    QuantLib::ext::shared_ptr<PricingEngine> yoyCapFloorEngine;
    QuantLib::ext::shared_ptr<PricingEngine> yoySwapEngine;
    QuantLib::ext::shared_ptr<InflationCouponPricer> yoyCouponPricer;
 
    for (auto& ci : calibrationBasket) {
 
        if (QuantLib::ext::shared_ptr<CpiCapFloorHelper> h = QuantLib::ext::dynamic_pointer_cast<CpiCapFloorHelper>(ci)) {
            if (!cpiCapFloorEngine) {
                cpiCapFloorEngine = QuantLib::ext::make_shared<AnalyticJyCpiCapFloorEngine>(*model_, modelIdx);
            }
            h->setPricingEngine(cpiCapFloorEngine);
            continue;
        }
 
        if (QuantLib::ext::shared_ptr<YoYCapFloorHelper> h = QuantLib::ext::dynamic_pointer_cast<YoYCapFloorHelper>(ci)) {
            if (!yoyCapFloorEngine) {
                yoyCapFloorEngine =
                    QuantLib::ext::make_shared<AnalyticJyYoYCapFloorEngine>(*model_, modelIdx, indexIsInterpolated);
            }
            h->setPricingEngine(yoyCapFloorEngine);
            continue;
        }
 
        if (QuantLib::ext::shared_ptr<YoYSwapHelper> h = QuantLib::ext::dynamic_pointer_cast<YoYSwapHelper>(ci)) {
            // Here we need to attach the coupon pricer to all the YoY coupons and then the generic discounting swap
            // engine to the helper.
            if (!yoyCouponPricer) {
                yoyCouponPricer = QuantLib::ext::make_shared<JyYoYInflationCouponPricer>(*model_, modelIdx);
 
                Size irIdx = model_->ccyIndex(model_->infjy(modelIdx)->currency());
                auto yts = model_->irlgm1f(irIdx)->termStructure();
                yoySwapEngine = QuantLib::ext::make_shared<DiscountingSwapEngine>(yts);
            }
 
            const auto& yoyLeg = h->yoySwap()->yoyLeg();
            for (const auto& cf : yoyLeg) {
                if (auto yoyCoupon = QuantLib::ext::dynamic_pointer_cast<YoYInflationCoupon>(cf))
                    yoyCoupon->setPricer(yoyCouponPricer);
            }
 
            h->setPricingEngine(yoySwapEngine);
            continue;
        }
 
        QL_FAIL("Only CPI cap floors, YoY cap floors and YoY swaps are supported for JY calibration.");
    }
 
    DLOG("Finished setting pricing engines on JY calibration instruments.");
}