Builder for a Hull White model or a HW component for the CAM. More...

#include <ored/model/hwbuilder.hpp>

Inheritance diagram for HwBuilder:

Collaboration diagram for HwBuilder:

Public Member Functions
	HwBuilder (const QuantLib::ext::shared_ptr< ore::data::Market > &market, const QuantLib::ext::shared_ptr< HwModelData > &data, const IrModel::Measure measure=IrModel::Measure::BA, const HwModel::Discretization discretization=HwModel::Discretization::Euler, const bool evaluateBankAccount=true, const std::string &configuration=Market::defaultConfiguration, Real bootstrapTolerance=0.001, const bool continueOnError=false, const std::string &referenceCalibrationGrid="", const bool setCalibrationInfo=false)

Real	error () const
	Return calibration error. More...

Inspectors
std::string	qualifier ()

std::string	ccy ()

QuantLib::ext::shared_ptr< QuantExt::HwModel >	model () const

QuantLib::ext::shared_ptr< QuantExt::IrHwParametrization >	parametrization () const

RelinkableHandle< YieldTermStructure >	discountCurve ()

std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > >	swaptionBasket () const

Public Member Functions inherited from ModelBuilder
void	recalibrate () const

virtual void	forceRecalculate ()

virtual bool	requiresRecalibration () const=0

ModelBuilder interface
QuantLib::ext::shared_ptr< ore::data::Market >	market_

const std::string	configuration_

QuantLib::ext::shared_ptr< HwModelData >	data_

IrModel::Measure	measure_

HwModel::Discretization	discretization_

bool	evaluateBankAccount_

const std::string	referenceCalibrationGrid_

bool	requiresCalibration_ = false

std::string	currency_

Real	error_

QuantLib::ext::shared_ptr< QuantExt::HwModel >	model_

Array	params_

QuantLib::ext::shared_ptr< QuantExt::IrHwParametrization >	parametrization_

std::vector< bool >	swaptionActive_

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

std::vector< Real >	swaptionStrike_

std::vector< QuantLib::ext::shared_ptr< SimpleQuote > >	swaptionBasketVols_

Array	swaptionExpiries_

Array	swaptionMaturities_

Date	swaptionBasketRefDate_

RelinkableHandle< YieldTermStructure >	modelDiscountCurve_

Handle< YieldTermStructure >	calibrationDiscountCurve_

Handle< QuantLib::SwaptionVolatilityStructure >	svts_

Handle< SwapIndex >	swapIndex_

Handle< SwapIndex >	shortSwapIndex_

QuantLib::ext::shared_ptr< OptimizationMethod >	optimizationMethod_

EndCriteria	endCriteria_

std::vector< QuantLib::Real >	swaptionVolCache_

bool	forceCalibration_ = false

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

void	forceRecalculate () override

bool	requiresRecalibration () const override

void	performCalculations () const override

Detailed Description

Builder for a Hull White model or a HW component for the CAM.

Definition at line 44 of file hwbuilder.hpp.

Constructor & Destructor Documentation

◆ HwBuilder()

HwBuilder	(	const QuantLib::ext::shared_ptr< ore::data::Market > &	market,
		const QuantLib::ext::shared_ptr< HwModelData > &	data,
		const IrModel::Measure	measure = `IrModel::Measure::BA`,
		const HwModel::Discretization	discretization = `HwModel::Discretization::Euler`,
		const bool	evaluateBankAccount = `true`,
		const std::string &	configuration = `Market::defaultConfiguration`,
		Real	bootstrapTolerance = `0.001`,
		const bool	continueOnError = `false`,
		const std::string &	referenceCalibrationGrid = `""`,
		const bool	setCalibrationInfo = `false`
	)

The configuration should refer to the calibration configuration here, alternative discounting curves are then usually set in the pricing engines for swaptions etc.

Definition at line 43 of file hwbuilder.cpp.

    : market_(market), configuration_(configuration), data_(data), measure_(measure), discretization_(discretization),
      /*bootstrapTolerance_(bootstrapTolerance), continueOnError_(continueOnError),*/
      referenceCalibrationGrid_(referenceCalibrationGrid), /*setCalibrationInfo_(setCalibrationInfo),*/
      optimizationMethod_(QuantLib::ext::shared_ptr<OptimizationMethod>(new LevenbergMarquardt(1E-8, 1E-8, 1E-8))),
      endCriteria_(EndCriteria(1000, 500, 1E-8, 1E-8, 1E-8))
      /*,calibrationErrorType_(BlackCalibrationHelper::RelativePriceError)*/ {
 
    marketObserver_ = QuantLib::ext::make_shared<MarketObserver>();
    string qualifier = data_->qualifier();
    currency_ = qualifier;
    QuantLib::ext::shared_ptr<IborIndex> index;
    if (tryParseIborIndex(qualifier, index)) {
        currency_ = index->currency().code();
    }
    LOG("HwCalibration for qualifier " << qualifier << " (ccy=" << currency_ << "), configuration is "
                                       << configuration_);
    Currency ccy = parseCurrency(currency_);
 
    requiresCalibration_ =
        (data_->calibrateSigma() || data_->calibrateKappa()) && data_->calibrationType() != CalibrationType::None;
 
    QL_REQUIRE(!requiresCalibration_, "HwBuilder: HwModel does not support calibration at the moment.");
 
    // the discount curve underlying the model might be relinked to a different curve outside this builder
    // the calibration curve should always stay the same though, therefore we create a different handle for this
    modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*market_->discountCurve(currency_, configuration_));
    calibrationDiscountCurve_ = Handle<YieldTermStructure>(*modelDiscountCurve_);
 
    if (requiresCalibration_) {
        svts_ = market_->swaptionVol(data_->qualifier(), configuration_);
        swapIndex_ = market_->swapIndex(market_->swapIndexBase(data_->qualifier(), configuration_), configuration_);
        shortSwapIndex_ =
            market_->swapIndex(market_->shortSwapIndexBase(data_->qualifier(), configuration_), configuration_);
        registerWith(svts_);
        marketObserver_->addObservable(swapIndex_->forwardingTermStructure());
        marketObserver_->addObservable(swapIndex_->discountingTermStructure());
        marketObserver_->addObservable(shortSwapIndex_->forwardingTermStructure());
        marketObserver_->addObservable(shortSwapIndex_->discountingTermStructure());
    }
    marketObserver_->addObservable(calibrationDiscountCurve_);
    registerWith(marketObserver_);
    // notify observers of all market data changes, not only when not calculated
    alwaysForwardNotifications();
 
    swaptionActive_ = std::vector<bool>(data_->optionExpiries().size(), false);
 
    if (requiresCalibration_) {
        // buildSwaptionBasket();
    }
 
    Array sigmaTimes(data_->sigmaTimes().begin(), data_->sigmaTimes().end());
    Array kappaTimes(data_->kappaTimes().begin(), data_->kappaTimes().end());
    std::vector<Matrix> sigma(data_->sigmaValues().begin(), data_->sigmaValues().end());
    std::vector<Array> kappa(data_->kappaValues().begin(), data_->kappaValues().end());
 
    QL_REQUIRE(data_->sigmaType() == ParamType::Constant,
               "HwBuilder: only constant sigma is supported at the moment");
    QL_REQUIRE(data_->kappaType() == ParamType::Constant,
               "HwBuilder: only constant sigma is supported at the moment");
 
    if (data_->sigmaType() == ParamType::Constant) {
        QL_REQUIRE(data_->sigmaTimes().size() == 0,
                   "HwBuilder: empty volatility time grid expected for constant parameter type");
        QL_REQUIRE(data_->sigmaValues().size() == 1,
                   "HwBuilder: initial volatility values should have size 1 for constant parameter type");
    } else if (data_->sigmaType() == ParamType::Piecewise) {
        if (data_->calibrateSigma() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (data_->sigmaTimes().size() > 0) {
                DLOG("overriding alpha time grid with swaption expiries, set all initial values to first given value");
            }
            QL_REQUIRE(swaptionExpiries_.size() > 0, "empty swaptionExpiries");
            sigmaTimes = Array(swaptionExpiries_.begin(), swaptionExpiries_.end() - 1);
            sigma = std::vector<Matrix>(sigmaTimes.size() + 1, data_->sigmaValues()[0]);
        } else {
            QL_REQUIRE(sigma.size() == sigmaTimes.size() + 1,
                       "HwBBuilder: hw volatility time and initial value array sizes do not match");
        }
    } else {
        QL_FAIL("HwBuilder: volatility parameter type not covered");
    }
 
    if (data_->kappaType() == ParamType::Constant) {
        QL_REQUIRE(data_->kappaTimes().size() == 0,
                   "HwBuilder: empty reversion time grid expected for constant parameter type");
        QL_REQUIRE(data_->kappaValues().size() == 1,
                   "HwBuidler: initial reversion values should have size 1 for constant parameter type");
    } else if (data_->kappaType() == ParamType::Piecewise) {
        if (data_->calibrateKappa() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (data_->kappaTimes().size() > 0) {
                DLOG("overriding h time grid with swaption underlying maturities, set all initial values to first "
                     "given value");
            }
            kappaTimes = swaptionMaturities_;
            kappa = std::vector<Array>(kappaTimes.size() + 1, data_->kappaValues()[0]);
        } else { // use input time grid and input h array otherwise
            QL_REQUIRE(kappa.size() == kappaTimes.size() + 1, "HwBuilder:: hw kappa grids do not match");
        }
    } else
        QL_FAIL("HwBuilder: reversion parameter type case not covered");
 
    DLOGGERSTREAM("before calibration: sigma times = " << sigmaTimes);
    DLOGGERSTREAM("before calibration: kappa times = " << kappaTimes);
 
    parametrization_ =
        QuantLib::ext::make_shared<QuantExt::IrHwConstantParametrization>(ccy, modelDiscountCurve_, sigma[0], kappa[0]);
 
    DLOG("alpha times size: " << sigmaTimes.size());
    DLOG("lambda times size: " << kappaTimes.size());
 
    model_ = QuantLib::ext::make_shared<QuantExt::HwModel>(parametrization_, measure_, discretization_, evaluateBankAccount_);
    params_ = model_->params();
}

Here is the call graph for this function:

Member Function Documentation

◆ error()

Real error ( ) const

Return calibration error.

Definition at line 161 of file hwbuilder.cpp.

                            {
    calculate();
    return error_;
}

◆ qualifier()

std::string qualifier ( )

Definition at line 60 of file hwbuilder.hpp.

60{ return data_->qualifier(); }

Here is the caller graph for this function:

◆ ccy()

std::string ccy ( )

Definition at line 61 of file hwbuilder.hpp.

61{ return currency_; }

Here is the caller graph for this function:

◆ model()

QuantLib::ext::shared_ptr< QuantExt::HwModel > model ( ) const

Definition at line 166 of file hwbuilder.cpp.

                                                              {
    calculate();
    return model_;
}

◆ parametrization()

QuantLib::ext::shared_ptr< QuantExt::IrHwParametrization > parametrization ( ) const

Definition at line 171 of file hwbuilder.cpp.

                                                                                    {
    calculate();
    return parametrization_;
}

◆ discountCurve()

RelinkableHandle< YieldTermStructure > discountCurve ( )

Definition at line 64 of file hwbuilder.hpp.

64{ return modelDiscountCurve_; }

◆ swaptionBasket()

std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > > swaptionBasket ( ) const

Definition at line 176 of file hwbuilder.cpp.

                                                                                         {
    calculate();
    return swaptionBasket_;
}

◆ forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 196 of file hwbuilder.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 181 of file hwbuilder.cpp.

                                            {
    // TODO
    // return requiresCalibration_ &&
    //        (volSurfaceChanged(false) || marketObserver_->hasUpdated(false) || forceCalibration_);
    return false;
}

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 188 of file hwbuilder.cpp.

                                          {
 
    DLOG("Recalibrate HW model for qualifier " << data_->qualifier() << " currency " << currency_);
 
    // TODO...
 
} // performCalculations()

Member Data Documentation

◆ market_

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

private

Definition at line 77 of file hwbuilder.hpp.

◆ configuration_

const std::string configuration_

private

Definition at line 78 of file hwbuilder.hpp.

◆ data_

QuantLib::ext::shared_ptr<HwModelData> data_

private

Definition at line 79 of file hwbuilder.hpp.

◆ measure_

IrModel::Measure measure_

private

Definition at line 80 of file hwbuilder.hpp.

◆ discretization_

HwModel::Discretization discretization_

private

Definition at line 81 of file hwbuilder.hpp.

◆ evaluateBankAccount_

bool evaluateBankAccount_

private

Definition at line 82 of file hwbuilder.hpp.

◆ referenceCalibrationGrid_

const std::string referenceCalibrationGrid_

private

Definition at line 85 of file hwbuilder.hpp.

◆ requiresCalibration_

bool requiresCalibration_ = false

private

Definition at line 87 of file hwbuilder.hpp.

◆ currency_

std::string currency_

private

Definition at line 88 of file hwbuilder.hpp.

◆ error_

Real error_

mutableprivate

Definition at line 90 of file hwbuilder.hpp.

◆ model_

QuantLib::ext::shared_ptr<QuantExt::HwModel> model_

mutableprivate

Definition at line 91 of file hwbuilder.hpp.

◆ params_

Array params_

mutableprivate

Definition at line 92 of file hwbuilder.hpp.

◆ parametrization_

QuantLib::ext::shared_ptr<QuantExt::IrHwParametrization> parametrization_

mutableprivate

Definition at line 93 of file hwbuilder.hpp.

◆ swaptionActive_

std::vector<bool> swaptionActive_

mutableprivate

Definition at line 96 of file hwbuilder.hpp.

◆ swaptionBasket_

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

mutableprivate

Definition at line 97 of file hwbuilder.hpp.

◆ swaptionStrike_

std::vector<Real> swaptionStrike_

mutableprivate

Definition at line 98 of file hwbuilder.hpp.

◆ swaptionBasketVols_

std::vector<QuantLib::ext::shared_ptr<SimpleQuote> > swaptionBasketVols_

mutableprivate

Definition at line 99 of file hwbuilder.hpp.

◆ swaptionExpiries_

Array swaptionExpiries_

mutableprivate

Definition at line 100 of file hwbuilder.hpp.

◆ swaptionMaturities_

Array swaptionMaturities_

mutableprivate

Definition at line 101 of file hwbuilder.hpp.

◆ swaptionBasketRefDate_

Date swaptionBasketRefDate_

mutableprivate

Definition at line 102 of file hwbuilder.hpp.

◆ modelDiscountCurve_

RelinkableHandle<YieldTermStructure> modelDiscountCurve_

private

Definition at line 104 of file hwbuilder.hpp.

◆ calibrationDiscountCurve_

Handle<YieldTermStructure> calibrationDiscountCurve_

private

Definition at line 105 of file hwbuilder.hpp.

◆ svts_

Handle<QuantLib::SwaptionVolatilityStructure> svts_

private

Definition at line 106 of file hwbuilder.hpp.

◆ swapIndex_

Handle<SwapIndex> swapIndex_

private

Definition at line 107 of file hwbuilder.hpp.

◆ shortSwapIndex_

Handle<SwapIndex> shortSwapIndex_

private

Definition at line 107 of file hwbuilder.hpp.

◆ optimizationMethod_

QuantLib::ext::shared_ptr<OptimizationMethod> optimizationMethod_

private

Definition at line 110 of file hwbuilder.hpp.

◆ endCriteria_

EndCriteria endCriteria_

private

Definition at line 111 of file hwbuilder.hpp.

◆ swaptionVolCache_

std::vector<QuantLib::Real> swaptionVolCache_

mutableprivate

Definition at line 115 of file hwbuilder.hpp.

◆ forceCalibration_

bool forceCalibration_ = false

private

Definition at line 117 of file hwbuilder.hpp.

◆ marketObserver_

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

private

Definition at line 120 of file hwbuilder.hpp.

Public Member Functions

ModelBuilder interface

Detailed Description

Constructor & Destructor Documentation

◆ HwBuilder()

Member Function Documentation

◆ error()

◆ qualifier()

◆ ccy()

◆ model()

◆ parametrization()

◆ discountCurve()

◆ swaptionBasket()

◆ forceRecalculate()

◆ requiresRecalibration()

◆ performCalculations()

Member Data Documentation

◆ market_

◆ configuration_

◆ data_

◆ measure_

◆ discretization_

◆ evaluateBankAccount_

◆ referenceCalibrationGrid_

◆ requiresCalibration_

◆ currency_

◆ error_

◆ model_

◆ params_

◆ parametrization_

◆ swaptionActive_

◆ swaptionBasket_

◆ swaptionStrike_

◆ swaptionBasketVols_

◆ swaptionExpiries_

◆ swaptionMaturities_

◆ swaptionBasketRefDate_

◆ modelDiscountCurve_

◆ calibrationDiscountCurve_

◆ svts_

◆ swapIndex_

◆ shortSwapIndex_

◆ optimizationMethod_

◆ endCriteria_

◆ swaptionVolCache_

◆ forceCalibration_

◆ marketObserver_