LgmBuilder Class Reference

Builder for a Linear Gauss Markov model component. More...

#include <ored/model/lgmbuilder.hpp>

Inheritance diagram for LgmBuilder:

Collaboration diagram for LgmBuilder:

Public Member Functions
	LgmBuilder (const QuantLib::ext::shared_ptr< ore::data::Market > &market, const QuantLib::ext::shared_ptr< IrLgmData > &data, const std::string &configuration=Market::defaultConfiguration, Real bootstrapTolerance=0.001, const bool continueOnError=false, const std::string &referenceCalibrationGrid="", const bool setCalibrationInfo=false, const std::string &id="unknwon")
Real	error () const
	Return calibration error. More...
Inspectors
std::string	qualifier ()
std::string	ccy ()
QuantLib::ext::shared_ptr< QuantExt::LGM >	model () const
RelinkableHandle< YieldTermStructure >	discountCurve ()
QuantLib::ext::shared_ptr< QuantExt::IrLgm1fParametrization >	parametrization () const
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< IrLgmData >	data_
const Real	bootstrapTolerance_
const bool	continueOnError_
const std::string	referenceCalibrationGrid_
const bool	setCalibrationInfo_
const std::string	id_
bool	requiresCalibration_ = false
std::string	currency_
Real	error_
QuantLib::ext::shared_ptr< QuantExt::LGM >	model_
Array	params_
QuantLib::ext::shared_ptr< QuantExt::IrLgm1fParametrization >	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_
Handle< QuantLib::SwaptionVolatilityStructure >	svts_
Handle< SwapIndex >	swapIndex_
Handle< SwapIndex >	shortSwapIndex_
RelinkableHandle< YieldTermStructure >	modelDiscountCurve_
Handle< YieldTermStructure >	calibrationDiscountCurve_
QuantLib::ext::shared_ptr< OptimizationMethod >	optimizationMethod_
EndCriteria	endCriteria_
BlackCalibrationHelper::CalibrationErrorType	calibrationErrorType_
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
void	buildSwaptionBasket () const
void	updateSwaptionBasketVols () const
std::string	getBasketDetails (QuantExt::LgmCalibrationInfo &info) const
bool	volSurfaceChanged (const bool updateCache) const
void	getExpiryAndTerm (const Size j, Period &expiryPb, Period &termPb, Date &expiryDb, Date &termDb, Real &termT, bool &expiryDateBased, bool &termDateBased) const
Real	getStrike (const Size j) const

Detailed Description

Builder for a Linear Gauss Markov model component.

This class is a utility that turns a Linear Gauss Markov model description into an interest rate model parametrisation which can be used to instantiate a CrossAssetModel.

Definition at line 48 of file lgmbuilder.hpp.

Constructor & Destructor Documentation

LgmBuilder()

LgmBuilder	(	const QuantLib::ext::shared_ptr< ore::data::Market > &	market,
		const QuantLib::ext::shared_ptr< IrLgmData > &	data,
		const std::string &	configuration = Market::defaultConfiguration,
		Real	bootstrapTolerance = 0.001,
		const bool	continueOnError = false,
		const std::string &	referenceCalibrationGrid = "",
		const bool	setCalibrationInfo = false,
		const std::string &	id = "unknwon"
	)

The configuration refers to the configuration to read swaption vol and swap index from the market. The discounting curve to price calibrating swaptions is derived from the swap index directly though, i.e. it is not read as a discount curve from the market (except as a fallback in case we do not find the swap index).

Definition at line 167 of file lgmbuilder.cpp.

    : market_(market), configuration_(configuration), data_(data), bootstrapTolerance_(bootstrapTolerance),
      continueOnError_(continueOnError), referenceCalibrationGrid_(referenceCalibrationGrid),
      setCalibrationInfo_(setCalibrationInfo), 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)),
      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("LgmCalibration for qualifier " << qualifier << " (ccy=" << currency_ << "), configuration is "
                                        << configuration_);
    Currency ccy = parseCurrency(currency_);
 
    requiresCalibration_ =
        (data_->calibrateA() || data_->calibrateH()) && data_->calibrationType() != CalibrationType::None;
 
    try {
        shortSwapIndex_ =
            market_->swapIndex(market_->shortSwapIndexBase(data_->qualifier(), configuration_), configuration_);
        swapIndex_ = market_->swapIndex(market_->swapIndexBase(data_->qualifier(), configuration_), configuration_);
        svts_ = market_->swaptionVol(data_->qualifier(), configuration_);
        // see the comment for dinscountCurve() in the interface
        modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
        calibrationDiscountCurve_ = Handle<YieldTermStructure>(*swapIndex_->discountingTermStructure());
    } catch (const std::exception& e) {
        StructuredModelErrorMessage(
            "Error when retrieving swap index base for qualifier '" + data_->qualifier() +
                "'. Use market discount curve instead of swap index discount curve as a fallback.",
            e.what(), id_)
            .log();
        modelDiscountCurve_ = RelinkableHandle<YieldTermStructure>(*market_->discountCurve(currency_, configuration_));
        calibrationDiscountCurve_ = Handle<YieldTermStructure>(*market_->discountCurve(currency_, configuration_));
    }
 
    if (requiresCalibration_) {
        registerWith(svts_);
        marketObserver_->addObservable(swapIndex_->forwardingTermStructure());
        marketObserver_->addObservable(shortSwapIndex_->forwardingTermStructure());
        marketObserver_->addObservable(shortSwapIndex_->discountingTermStructure());
    }
    // we do not register with modelDiscountCurve_, since this curve does not affect the calibration
    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 aTimes(data_->aTimes().begin(), data_->aTimes().end());
    Array hTimes(data_->hTimes().begin(), data_->hTimes().end());
    Array alpha(data_->aValues().begin(), data_->aValues().end());
    Array h(data_->hValues().begin(), data_->hValues().end());
 
    if (data_->aParamType() == ParamType::Constant) {
        QL_REQUIRE(data_->aTimes().size() == 0,
                   "LgmBuilder: empty volatility time grid expected for constant parameter type");
        QL_REQUIRE(data_->aValues().size() == 1,
                   "LgmBuilder: initial volatility values should have size 1 for constant parameter type");
    } else if (data_->aParamType() == ParamType::Piecewise) {
        if (data_->calibrateA() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (data_->aTimes().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");
            aTimes = Array(swaptionExpiries_.begin(), swaptionExpiries_.end() - 1);
            alpha = Array(aTimes.size() + 1, data_->aValues()[0]);
        } else {
            QL_REQUIRE(alpha.size() == aTimes.size() + 1,
                       "LgmBuilder: LGM volatility time and initial value array sizes do not match");
        }
    } else
        QL_FAIL("LgmBuilder: volatility parameter type not covered");
 
    if (data_->hParamType() == ParamType::Constant) {
        QL_REQUIRE(data_->hTimes().size() == 0,
                   "LgmBuilder: empty reversion time grid expected for constant parameter type");
        QL_REQUIRE(data_->hValues().size() == 1,
                   "LgmBuidler: initial reversion values should have size 1 for constant parameter type");
    } else if (data_->hParamType() == ParamType::Piecewise) {
        if (data_->calibrateH() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (data_->hTimes().size() > 0) {
                DLOG("overriding h time grid with swaption underlying maturities, set all initial values to first "
                     "given value");
            }
            hTimes = swaptionMaturities_;
            h = Array(hTimes.size() + 1, data_->hValues()[0]);
        } else { // use input time grid and input h array otherwise
            QL_REQUIRE(h.size() == hTimes.size() + 1, "H grids do not match");
        }
    } else
        QL_FAIL("LgmBuilder: reversion parameter type case not covered");
 
    DLOG("before calibration: alpha times = " << aTimes << " values = " << alpha);
    DLOG("before calibration:     h times = " << hTimes << " values = " << h);
 
    if (data_->reversionType() == LgmData::ReversionType::HullWhite &&
        data_->volatilityType() == LgmData::VolatilityType::HullWhite) {
        DLOG("IR parametrization for " << qualifier << ": IrLgm1fPiecewiseConstantHullWhiteAdaptor");
        parametrization_ = QuantLib::ext::make_shared<QuantExt::IrLgm1fPiecewiseConstantHullWhiteAdaptor>(
            ccy, modelDiscountCurve_, aTimes, alpha, hTimes, h);
    } else if (data_->reversionType() == LgmData::ReversionType::HullWhite &&
               data_->volatilityType() == LgmData::VolatilityType::Hagan) {
        DLOG("IR parametrization for " << qualifier << ": IrLgm1fPiecewiseConstant");
        parametrization_ = QuantLib::ext::make_shared<QuantExt::IrLgm1fPiecewiseConstantParametrization>(
            ccy, modelDiscountCurve_, aTimes, alpha, hTimes, h);
    } else if (data_->reversionType() == LgmData::ReversionType::Hagan &&
               data_->volatilityType() == LgmData::VolatilityType::Hagan) {
        parametrization_ = QuantLib::ext::make_shared<QuantExt::IrLgm1fPiecewiseLinearParametrization>(
            ccy, modelDiscountCurve_, aTimes, alpha, hTimes, h);
        DLOG("IR parametrization for " << qualifier << ": IrLgm1fPiecewiseLinear");
    } else {
        QL_FAIL("LgmBuilder: Reversion type Hagan and volatility type HullWhite not covered");
    }
    DLOG("alpha times size: " << aTimes.size());
    DLOG("lambda times size: " << hTimes.size());
 
    model_ = QuantLib::ext::make_shared<QuantExt::LGM>(parametrization_);
    params_ = model_->params();
}

Here is the call graph for this function:

Member Function Documentation

error()

Real error

(

)

const

Return calibration error.

Definition at line 300 of file lgmbuilder.cpp.

                             {
    calculate();
    return error_;
}

qualifier()

std::string qualifier

(

)

Definition at line 63 of file lgmbuilder.hpp.

{ return data_->qualifier(); }

Here is the caller graph for this function:

ccy()

std::string ccy

(

)

Definition at line 64 of file lgmbuilder.hpp.

{ return currency_; }

Here is the caller graph for this function:

model()

QuantLib::ext::shared_ptr< QuantExt::LGM > model

(

)

const

Definition at line 305 of file lgmbuilder.cpp.

                                                           {
    calculate();
    return model_;
}

discountCurve()

RelinkableHandle< YieldTermStructure > discountCurve

(

)

Definition at line 69 of file lgmbuilder.hpp.

{ return modelDiscountCurve_; }

parametrization()

QuantLib::ext::shared_ptr< QuantExt::IrLgm1fParametrization > parametrization

(

)

const

Definition at line 310 of file lgmbuilder.cpp.

                                                                                        {
    calculate();
    return parametrization_;
}

swaptionBasket()

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

(

)

const

Definition at line 315 of file lgmbuilder.cpp.

                                                                                          {
    calculate();
    return swaptionBasket_;
}

forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 692 of file lgmbuilder.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 320 of file lgmbuilder.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 325 of file lgmbuilder.cpp.

                                           {
 
    DLOG("Recalibrate LGM model for qualifier " << data_->qualifier() << " currency " << currency_);
 
    if (!requiresRecalibration()) {
        DLOG("Skipping calibration as nothing has changed");
        return;
    }
 
    // reset lgm observer's updated flag
    marketObserver_->hasUpdated(true);
 
    if (swaptionBasketRefDate_ != calibrationDiscountCurve_->referenceDate()) {
        // build swaption basket if required, i.e. if reference date has changed since last build
        buildSwaptionBasket();
        volSurfaceChanged(true);
        updateSwaptionBasketVols();
    } else {
        // otherwise just update vols
        volSurfaceChanged(true);
        updateSwaptionBasketVols();
    }
 
    for (Size j = 0; j < swaptionBasket_.size(); j++) {
        auto engine = QuantLib::ext::make_shared<QuantExt::AnalyticLgmSwaptionEngine>(model_, calibrationDiscountCurve_,
                                                                                      data_->floatSpreadMapping());
        engine->enableCache(!data_->calibrateH(), !data_->calibrateA());
        swaptionBasket_[j]->setPricingEngine(engine);
        // necessary if notifications are disabled (observation mode = Disable)
        swaptionBasket_[j]->update();
    }
 
    // reset model parameters to ensure identical results on identical market data input
    model_->setParams(params_);
    parametrization_->shift() = 0.0;
    parametrization_->scaling() = 1.0;
 
    LgmCalibrationInfo calibrationInfo;
    error_ = QL_MAX_REAL;
    std::string errorTemplate =
        std::string("Failed to calibrate LGM Model. ") +
        (continueOnError_ ? std::string("Calculation will proceed anyway - using the calibration as is!")
                          : std::string("Calculation will aborted."));
    try {
        if (data_->calibrateA() && !data_->calibrateH() && data_->calibrationType() == CalibrationType::Bootstrap) {
            DLOG("call calibrateVolatilitiesIterative for volatility calibration (bootstrap)");
            model_->calibrateVolatilitiesIterative(swaptionBasket_, *optimizationMethod_, endCriteria_);
        } else if (data_->calibrateH() && !data_->calibrateA() &&
                   data_->calibrationType() == CalibrationType::Bootstrap) {
            DLOG("call calibrateReversionsIterative for reversion calibration (bootstrap)");
            model_->calibrateVolatilitiesIterative(swaptionBasket_, *optimizationMethod_, endCriteria_);
        } else {
            QL_REQUIRE(data_->calibrationType() != CalibrationType::Bootstrap,
                       "LgmBuidler: Calibration type Bootstrap can be used with volatilities and reversions calibrated "
                       "simultaneously. Either choose BestFit oder fix one of these parameters.");
            if (data_->calibrateA() && !data_->calibrateH()) {
                DLOG("call calibrateVolatilities for (global) volatility calibration")
                model_->calibrateVolatilities(swaptionBasket_, *optimizationMethod_, endCriteria_);
            } else if (data_->calibrateH() && !data_->calibrateA()) {
                DLOG("call calibrateReversions for (global) reversion calibration")
                model_->calibrateReversions(swaptionBasket_, *optimizationMethod_, endCriteria_);
            } else {
                DLOG("call calibrate for global volatility and reversion calibration");
                model_->calibrate(swaptionBasket_, *optimizationMethod_, endCriteria_);
            }
        }
        TLOG("LGM " << data_->qualifier() << " calibration errors:");
        error_ = getCalibrationError(swaptionBasket_);
    } catch (const std::exception& e) {
        // just log a warning, we check below if we meet the bootstrap tolerance and handle the result there
        StructuredModelErrorMessage(errorTemplate, e.what(), id_).log();
    }
    calibrationInfo.rmse = error_;
    if (fabs(error_) < bootstrapTolerance_ ||
        (data_->calibrationType() == CalibrationType::BestFit && error_ != QL_MAX_REAL)) {
        // we check the log level here to avoid unnecessary computations
        if (Log::instance().filter(ORE_DATA) || setCalibrationInfo_) {
            TLOGGERSTREAM("Basket details:");
            try {
                auto d = getBasketDetails(calibrationInfo);
                TLOGGERSTREAM(d);
            } catch (const std::exception& e) {
                WLOG("An error occurred: " << e.what());
            }
            TLOGGERSTREAM("Calibration details (with time grid = calibration swaption expiries):");
            try {
                auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
                TLOGGERSTREAM(d);
            } catch (const std::exception& e) {
                WLOG("An error occurred: " << e.what());
            }
            TLOGGERSTREAM("Parameter details (with parameter time grid)");
            TLOGGERSTREAM(getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_))
            TLOGGERSTREAM("rmse = " << error_);
            calibrationInfo.valid = true;
        }
    } else {
        std::string exceptionMessage = "LGM (" + data_->qualifier() + ") calibration error " + std::to_string(error_) +
                                       " exceeds tolerance " + std::to_string(bootstrapTolerance_);
        StructuredModelErrorMessage(errorTemplate, exceptionMessage, id_).log();
        WLOGGERSTREAM("Basket details:");
        try {
            auto d = getBasketDetails(calibrationInfo);
            WLOGGERSTREAM(d);
        } catch (const std::exception& e) {
            WLOG("An error occurred: " << e.what());
        }
        WLOGGERSTREAM("Calibration details (with time grid = calibration swaption expiries):");
        try {
            auto d = getCalibrationDetails(calibrationInfo, swaptionBasket_, parametrization_);
            WLOGGERSTREAM(d);
        } catch (const std::exception& e) {
            WLOG("An error occurred: " << e.what());
        }
        WLOGGERSTREAM("Parameter details (with parameter time grid)");
        WLOGGERSTREAM(getCalibrationDetails(parametrization_));
        WLOGGERSTREAM("rmse = " << error_);
        calibrationInfo.valid = true;
        if (!continueOnError_) {
            QL_FAIL(exceptionMessage);
        }
    }
    model_->setCalibrationInfo(calibrationInfo);
 
    DLOG("Apply shift horizon and scale (if not 0.0 and 1.0 respectively)");
 
    QL_REQUIRE(data_->shiftHorizon() >= 0.0, "shift horizon must be non negative");
    QL_REQUIRE(data_->scaling() > 0.0, "scaling must be positive");
 
    if (data_->shiftHorizon() > 0.0) {
        Real value = -parametrization_->H(data_->shiftHorizon());
        DLOG("Apply shift horizon " << data_->shiftHorizon() << " (C=" << value << ") to the " << data_->qualifier()
                                    << " LGM model");
        parametrization_->shift() = value;
    }
 
    if (data_->scaling() != 1.0) {
        DLOG("Apply scaling " << data_->scaling() << " to the " << data_->qualifier() << " LGM model");
        parametrization_->scaling() = data_->scaling();
    }
} // performCalculations()

Here is the call graph for this function:

buildSwaptionBasket()

void buildSwaptionBasket ( ) const

private

Definition at line 557 of file lgmbuilder.cpp.

                                           {
 
    DLOG("build swaption basket");
 
    QL_REQUIRE(data_->optionExpiries().size() == data_->optionTerms().size(), "swaption vector size mismatch");
    QL_REQUIRE(data_->optionExpiries().size() == data_->optionStrikes().size(), "swaption vector size mismatch");
 
    std::ostringstream log;
 
    std::vector<Time> expiryTimes;
    std::vector<Time> maturityTimes;
    swaptionBasket_.clear();
    swaptionBasketVols_.clear();
    swaptionVolCache_.clear();
    swaptionStrike_.clear();
 
    DLOG("build reference date grid '" << referenceCalibrationGrid_ << "'");
    Date lastRefCalDate = Date::minDate();
    std::vector<Date> referenceCalibrationDates;
    if (!referenceCalibrationGrid_.empty())
        referenceCalibrationDates = DateGrid(referenceCalibrationGrid_).dates();
 
    for (Size j = 0; j < data_->optionExpiries().size(); j++) {
        bool expiryDateBased, termDateBased;
        Period expiryPb, termPb;
        Date expiryDb, termDb;
        Real termT = Null<Real>();
 
        getExpiryAndTerm(j, expiryPb, termPb, expiryDb, termDb, termT, expiryDateBased, termDateBased);
        Real strikeValue = getStrike(j);
 
        // rounded to whole years, only used to distinguish between short and long
        // swap tenors, which in practice always are multiples of whole years
        Period termTmp = static_cast<Size>(termT + 0.5) * Years;
        auto iborIndex = termTmp > shortSwapIndex_->tenor() ? swapIndex_->iborIndex() : shortSwapIndex_->iborIndex();
        auto fixedLegTenor =
            termTmp > shortSwapIndex_->tenor() ? swapIndex_->fixedLegTenor() : shortSwapIndex_->fixedLegTenor();
        auto fixedDayCounter =
            termTmp > shortSwapIndex_->tenor() ? swapIndex_->dayCounter() : shortSwapIndex_->dayCounter();
        auto floatDayCounter = termTmp > shortSwapIndex_->tenor() ? swapIndex_->iborIndex()->dayCounter()
                                                                  : shortSwapIndex_->iborIndex()->dayCounter();
        Size settlementDays = Null<Size>();
        RateAveraging::Type averagingMethod = RateAveraging::Compound;
        if (auto on = dynamic_pointer_cast<OvernightIndexedSwapIndex>(*swapIndex_)) {
            settlementDays = on->fixingDays();
            averagingMethod = on->averagingMethod();
        }
 
        Real dummyQuote = svts_->volatilityType() == Normal ? 0.0020 : 0.10;
        auto volQuote = QuantLib::ext::make_shared<SimpleQuote>(dummyQuote);
        Handle<Quote> vol = Handle<Quote>(volQuote);
        QuantLib::ext::shared_ptr<SwaptionHelper> helper;
        Real updatedStrike;
 
        if (expiryDateBased && termDateBased) {
            Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryDb, termT) : 0.0;
            std::tie(helper, updatedStrike) = createSwaptionHelper(
                expiryDb, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
                calibrationDiscountCurve_, calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
        }
        if (expiryDateBased && !termDateBased) {
            Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryDb, termPb) : 0.0;
            std::tie(helper, updatedStrike) = createSwaptionHelper(
                expiryDb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
                calibrationDiscountCurve_, calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
        }
        if (!expiryDateBased && termDateBased) {
            Date expiry = svts_->optionDateFromTenor(expiryPb);
            Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryPb, termT) : 0.0;
            std::tie(helper, updatedStrike) = createSwaptionHelper(
                expiry, termDb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
                calibrationDiscountCurve_, calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
        }
        if (!expiryDateBased && !termDateBased) {
            Real shift = svts_->volatilityType() == ShiftedLognormal ? svts_->shift(expiryPb, termPb) : 0.0;
            std::tie(helper, updatedStrike) = createSwaptionHelper(
                expiryPb, termPb, svts_, vol, iborIndex, fixedLegTenor, fixedDayCounter, floatDayCounter,
                calibrationDiscountCurve_, calibrationErrorType_, strikeValue, shift, settlementDays, averagingMethod);
        }
 
        // check if we want to keep the helper when a reference calibration grid is given
        Date expiryDate = helper->swaption()->exercise()->date(0);
        auto refCalDate =
            std::lower_bound(referenceCalibrationDates.begin(), referenceCalibrationDates.end(), expiryDate);
        if (refCalDate == referenceCalibrationDates.end() || *refCalDate > lastRefCalDate) {
            swaptionActive_[j] = true;
            swaptionBasketVols_.push_back(volQuote);
            swaptionBasket_.push_back(helper);
            swaptionStrike_.push_back(updatedStrike);
            expiryTimes.push_back(calibrationDiscountCurve_->timeFromReference(expiryDate));
            Date matDate = helper->underlyingSwap() ? helper->underlyingSwap()->maturityDate()
                                                    : helper->underlyingOvernightIndexedSwap()->maturityDate();
            maturityTimes.push_back(calibrationDiscountCurve_->timeFromReference(matDate));
            if (refCalDate != referenceCalibrationDates.end())
                lastRefCalDate = *refCalDate;
        }
    }
 
    std::sort(expiryTimes.begin(), expiryTimes.end());
    auto itExpiryTime = unique(expiryTimes.begin(), expiryTimes.end());
    expiryTimes.resize(distance(expiryTimes.begin(), itExpiryTime));
 
    swaptionExpiries_ = Array(expiryTimes.size());
    for (Size j = 0; j < expiryTimes.size(); j++)
        swaptionExpiries_[j] = expiryTimes[j];
 
    std::sort(maturityTimes.begin(), maturityTimes.end());
    auto itMaturityTime = unique(maturityTimes.begin(), maturityTimes.end());
    maturityTimes.resize(distance(maturityTimes.begin(), itMaturityTime));
 
    swaptionMaturities_ = Array(maturityTimes.size());
    for (Size j = 0; j < maturityTimes.size(); j++)
        swaptionMaturities_[j] = maturityTimes[j];
 
    swaptionBasketRefDate_ = calibrationDiscountCurve_->referenceDate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateSwaptionBasketVols()

void updateSwaptionBasketVols ( ) const

private

Definition at line 552 of file lgmbuilder.cpp.

                                                {
    for (Size j = 0; j < swaptionBasketVols_.size(); ++j)
        swaptionBasketVols_.at(j)->setValue(swaptionVolCache_.at(j));
}

Here is the caller graph for this function:

getBasketDetails()

std::string getBasketDetails ( QuantExt::LgmCalibrationInfo &  info ) const

private

Definition at line 674 of file lgmbuilder.cpp.

                                                                     {
    std::ostringstream log;
    log << std::right << std::setw(3) << "#" << std::setw(16) << "expiry" << std::setw(16) << "swapLength"
        << std::setw(16) << "strike" << std::setw(16) << "atmForward" << std::setw(16) << "annuity" << std::setw(16)
        << "vega" << std::setw(16) << "vol\n";
    info.swaptionData.clear();
    for (Size j = 0; j < swaptionBasket_.size(); ++j) {
        auto swp = QuantLib::ext::static_pointer_cast<SwaptionHelper>(swaptionBasket_[j])->swaption();
        auto sd = swaptionData(swp, calibrationDiscountCurve_, svts_);
        log << std::right << std::setw(3) << j << std::setw(16) << sd.timeToExpiry << std::setw(16) << sd.swapLength
            << std::setw(16) << sd.strike << std::setw(16) << sd.atmForward << std::setw(16) << sd.annuity
            << std::setw(16) << sd.vega << std::setw(16) << std::setw(16) << sd.stdDev / std::sqrt(sd.timeToExpiry)
            << "\n";
        info.swaptionData.push_back(sd);
    }
    return log.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

volSurfaceChanged()

bool volSurfaceChanged ( const bool  updateCache ) const

private

Definition at line 508 of file lgmbuilder.cpp.

                                                               {
    bool hasUpdated = false;
 
    // create cache if not equal to required size
    if (swaptionVolCache_.size() != swaptionBasket_.size())
        swaptionVolCache_ = vector<Real>(swaptionBasket_.size(), Null<Real>());
 
    Size swaptionCounter = 0;
    for (Size j = 0; j < data_->optionExpiries().size(); j++) {
        if (!swaptionActive_[j])
            continue;
 
        Real volCache = swaptionVolCache_.at(swaptionCounter);
 
        bool expiryDateBased, termDateBased;
        Period expiryPb, termPb;
        Date expiryDb, termDb;
        Real termT;
 
        getExpiryAndTerm(j, expiryPb, termPb, expiryDb, termDb, termT, expiryDateBased, termDateBased);
        Real strikeValue = swaptionStrike_.at(swaptionCounter);
 
        Real vol;
        if (expiryDateBased && termDateBased) {
            vol = svts_->volatility(expiryDb, termT, strikeValue);
        } else if (expiryDateBased && !termDateBased) {
            vol = svts_->volatility(expiryDb, termPb, strikeValue);
        } else if (!expiryDateBased && termDateBased) {
            vol = svts_->volatility(expiryPb, termT, strikeValue);
        } else {
            // !expiryDateBased && !termDateBased
            vol = svts_->volatility(expiryPb, termPb, strikeValue);
        }
 
        if (!close_enough(volCache, vol)) {
            if (updateCache)
                swaptionVolCache_[swaptionCounter] = vol;
            hasUpdated = true;
        }
        swaptionCounter++;
    }
    return hasUpdated;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getExpiryAndTerm()

void getExpiryAndTerm ( const Size  j, Period &  expiryPb, Period &  termPb, Date &  expiryDb, Date &  termDb, Real &  termT, bool &  expiryDateBased, bool &  termDateBased  ) const

private

Definition at line 467 of file lgmbuilder.cpp.

                                                                                                 {
    std::string expiryString = data_->optionExpiries()[j];
    std::string termString = data_->optionTerms()[j];
    parseDateOrPeriod(expiryString, expiryDb, expiryPb, expiryDateBased);
    parseDateOrPeriod(termString, termDb, termPb, termDateBased);
    if (termDateBased) {
        Date tmpExpiry = expiryDateBased ? expiryDb : svts_->optionDateFromTenor(expiryPb);
        Date tmpStart = swapIndex_->iborIndex()->valueDate(swapIndex_->iborIndex()->fixingCalendar().adjust(tmpExpiry));
        // ensure that we have a term >= 1 Month, otherwise QL might throw "non-positive swap length (0)  given" from
        // the black swaption engine during calibration helper pricing; also notice that we use the swap length
        // calculated in the svts (i.e. a length rounded to whole months) to read the volatility from the cube, which is
        // consistent with what is done in BlackSwaptionEngine (although one might ask whether an interpolated
        // volatility would be more appropriate)
        termDb = std::max(termDb, tmpStart + 1 * Months);
        termT = svts_->swapLength(tmpStart, termDb);
    } else {
        termT = svts_->swapLength(termPb);
        // same as above, make sure the underlying term is at least >= 1 Month, but since Period::operator<
        // throws in certain circumstances, we do the comparison based on termT here:
        if (termT < 1.0 / 12.0) {
            termT = 1.0 / 12.0;
            termPb = 1 * Months;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getStrike()

Real getStrike ( const Size  j ) const

private

Definition at line 494 of file lgmbuilder.cpp.

                                             {
    DLOG("LgmBuilder::getStrike(" << j << "): '" << data_->optionStrikes()[j] << "'");
    Strike strike = parseStrike(data_->optionStrikes()[j]);
    Real strikeValue;
    // TODO: Extend strike type coverage
    if (strike.type == Strike::Type::ATM)
        strikeValue = Null<Real>();
    else if (strike.type == Strike::Type::Absolute)
        strikeValue = strike.value;
    else
        QL_FAIL("strike type ATM or Absolute expected");
    return strikeValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

market_

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

private

Definition at line 93 of file lgmbuilder.hpp.

configuration_

const std::string configuration_

private

Definition at line 94 of file lgmbuilder.hpp.

data_

QuantLib::ext::shared_ptr<IrLgmData> data_

private

Definition at line 95 of file lgmbuilder.hpp.

bootstrapTolerance_

const Real bootstrapTolerance_

private

Definition at line 96 of file lgmbuilder.hpp.

continueOnError_

const bool continueOnError_

private

Definition at line 97 of file lgmbuilder.hpp.

referenceCalibrationGrid_

const std::string referenceCalibrationGrid_

private

Definition at line 98 of file lgmbuilder.hpp.

setCalibrationInfo_

const bool setCalibrationInfo_

private

Definition at line 99 of file lgmbuilder.hpp.

id_

const std::string id_

private

Definition at line 100 of file lgmbuilder.hpp.

requiresCalibration_

bool requiresCalibration_ = false

private

Definition at line 101 of file lgmbuilder.hpp.

currency_

std::string currency_

private

Definition at line 102 of file lgmbuilder.hpp.

error_

Real error_

mutableprivate

Definition at line 104 of file lgmbuilder.hpp.

model_

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

mutableprivate

Definition at line 105 of file lgmbuilder.hpp.

params_

Array params_

mutableprivate

Definition at line 106 of file lgmbuilder.hpp.

parametrization_

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

mutableprivate

Definition at line 107 of file lgmbuilder.hpp.

swaptionActive_

std::vector<bool> swaptionActive_

mutableprivate

Definition at line 110 of file lgmbuilder.hpp.

swaptionBasket_

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

mutableprivate

Definition at line 111 of file lgmbuilder.hpp.

swaptionStrike_

std::vector<Real> swaptionStrike_

mutableprivate

Definition at line 112 of file lgmbuilder.hpp.

swaptionBasketVols_

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

mutableprivate

Definition at line 113 of file lgmbuilder.hpp.

swaptionExpiries_

Array swaptionExpiries_

mutableprivate

Definition at line 114 of file lgmbuilder.hpp.

swaptionMaturities_

Array swaptionMaturities_

mutableprivate

Definition at line 115 of file lgmbuilder.hpp.

swaptionBasketRefDate_

Date swaptionBasketRefDate_

mutableprivate

Definition at line 116 of file lgmbuilder.hpp.

svts_

Handle<QuantLib::SwaptionVolatilityStructure> svts_

private

Definition at line 118 of file lgmbuilder.hpp.

swapIndex_

Handle<SwapIndex> swapIndex_

private

Definition at line 119 of file lgmbuilder.hpp.

shortSwapIndex_

Handle<SwapIndex> shortSwapIndex_

private

Definition at line 119 of file lgmbuilder.hpp.

modelDiscountCurve_

RelinkableHandle<YieldTermStructure> modelDiscountCurve_

private

Definition at line 120 of file lgmbuilder.hpp.

calibrationDiscountCurve_

Handle<YieldTermStructure> calibrationDiscountCurve_

private

Definition at line 121 of file lgmbuilder.hpp.

optimizationMethod_

QuantLib::ext::shared_ptr<OptimizationMethod> optimizationMethod_

private

Definition at line 124 of file lgmbuilder.hpp.

endCriteria_

EndCriteria endCriteria_

private

Definition at line 125 of file lgmbuilder.hpp.

calibrationErrorType_

BlackCalibrationHelper::CalibrationErrorType calibrationErrorType_

private

Definition at line 126 of file lgmbuilder.hpp.

swaptionVolCache_

std::vector<QuantLib::Real> swaptionVolCache_

mutableprivate

Definition at line 129 of file lgmbuilder.hpp.

forceCalibration_

bool forceCalibration_ = false

private

Definition at line 131 of file lgmbuilder.hpp.

marketObserver_

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

private

Definition at line 134 of file lgmbuilder.hpp.