InfDkBuilder Class Reference

#include <ored/model/inflation/infdkbuilder.hpp>

Inheritance diagram for InfDkBuilder:

Collaboration diagram for InfDkBuilder:

Public Member Functions
	InfDkBuilder (const QuantLib::ext::shared_ptr< ore::data::Market > &market, const QuantLib::ext::shared_ptr< InfDkData > &data, const std::string &configuration=Market::defaultConfiguration, const std::string &referenceCalibrationGrid="", const bool dontCalibrate=false)
Inspectors
std::string	infIndex ()
QuantLib::ext::shared_ptr< QuantExt::InfDkParametrization >	parametrization () const
std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > >	optionBasket () const
Public Member Functions inherited from ModelBuilder
void	recalibrate () const
virtual void	forceRecalculate ()
virtual bool	requiresRecalibration () const=0

ModelBuilder interface
const QuantLib::ext::shared_ptr< ore::data::Market >	market_
const std::string	configuration_
const QuantLib::ext::shared_ptr< InfDkData >	data_
const std::string	referenceCalibrationGrid_
QuantLib::ext::shared_ptr< QuantExt::InfDkParametrization >	parametrization_
std::vector< bool >	optionActive_
std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > >	optionBasket_
QuantLib::Array	optionExpiries_
QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex >	inflationIndex_
Handle< YieldTermStructure >	rateCurve_
QuantLib::Handle< QuantLib::CPIVolatilitySurface >	infVol_
std::vector< QuantLib::Real >	infPriceCache_
bool	forceCalibration_ = false
bool	dontCalibrate_ = false
QuantLib::ext::shared_ptr< QuantExt::MarketObserver >	marketObserver_
void	forceRecalculate () override
bool	requiresRecalibration () const override
void	setCalibrationDone () const
void	performCalculations () const override
Real	optionStrikeValue (const Size j) const
Date	optionMaturityDate (const Size j) const
void	buildCapFloorBasket () const
bool	volSurfaceChanged (const bool updateCache) const

Detailed Description

Builder for a Dodgson-Kainth inflation model component

This class is a utility to turn a Dodgson-Kainth inflation model component description into an inflation model parameterization which can be used to instantiate a CrossAssetModel.

Definition at line 45 of file infdkbuilder.hpp.

Constructor & Destructor Documentation

InfDkBuilder()

InfDkBuilder	(	const QuantLib::ext::shared_ptr< ore::data::Market > &	market,
		const QuantLib::ext::shared_ptr< InfDkData > &	data,
		const std::string &	configuration = Market::defaultConfiguration,
		const std::string &	referenceCalibrationGrid = "",
		const bool	dontCalibrate = false
	)

Constructor

Parameters

market	Market object
data	Dodgson-Kainth inflation model description
configuration	Market configuration to use
referenceCalibrationGrid	The reference calibration grid
dontCalibrate	Flag to use a dummy basecpi for the dependency market run

Definition at line 44 of file infdkbuilder.cpp.

    : market_(market), configuration_(configuration), data_(data), referenceCalibrationGrid_(referenceCalibrationGrid),
      dontCalibrate_(dontCalibrate) {
 
    LOG("DkBuilder for " << data_->index());
 
    if (!data_->calibrationBaskets().empty()) {
        QL_REQUIRE(data_->calibrationBaskets().size() == 1, "If there is a calibration basket, expect exactly 1.");
        const CalibrationBasket& cb = data_->calibrationBaskets()[0];
        QL_REQUIRE(!cb.empty(), "If there is a calibration basket, expect it to be non-empty.");
        optionActive_ = vector<bool>(cb.instruments().size(), false);
    }
 
    marketObserver_ = QuantLib::ext::make_shared<MarketObserver>();
 
    // get market data
    inflationIndex_ =
        QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndex>(*market_->zeroInflationIndex(data_->index(), configuration_));
    QL_REQUIRE(inflationIndex_, "DkBuilder: requires ZeroInflationIndex, got " << data_->index());
    rateCurve_ = market_->discountCurve(inflationIndex_->currency().code(), configuration_);
    infVol_ = market_->cpiInflationCapFloorVolatilitySurface(data_->index(), configuration_);
 
    // register with market observables except vols
    marketObserver_->registerWith(inflationIndex_);
    marketObserver_->registerWith(rateCurve_);
 
    // register the builder with the market observer
    registerWith(marketObserver_);
    registerWith(infVol_);
    // notify observers of all market data changes, not only when not calculated
    alwaysForwardNotifications();
 
    // build option basket and derive parametrization from it
    const ReversionParameter& reversion = data_->reversion();
    const VolatilityParameter& volatility = data_->volatility();
    if (volatility.calibrate() || reversion.calibrate())
        buildCapFloorBasket();
 
    Array aTimes(volatility.times().begin(), volatility.times().end());
    Array hTimes(reversion.times().begin(), reversion.times().end());
    Array alpha(volatility.values().begin(), volatility.values().end());
    Array h(reversion.values().begin(), reversion.values().end());
 
    if (volatility.type() == ParamType::Constant) {
        QL_REQUIRE(volatility.times().size() == 0, "empty alpha times expected");
        QL_REQUIRE(volatility.values().size() == 1, "initial alpha array should have size 1");
    } else if (volatility.type() == ParamType::Piecewise) {
        if (volatility.calibrate() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (volatility.times().size() > 0) {
                DLOG("overriding alpha time grid with option expiries");
            }
            QL_REQUIRE(optionExpiries_.size() > 0, "empty option expiries");
            aTimes = Array(optionExpiries_.begin(), optionExpiries_.end() - 1);
            alpha = Array(aTimes.size() + 1, volatility.values()[0]);
        } else { // use input time grid and input alpha array otherwise
            QL_REQUIRE(alpha.size() == aTimes.size() + 1, "alpha grids do not match");
        }
    } else {
        QL_FAIL("Expected DK model data volatility parameter to be Constant or Piecewise.");
    }
 
    if (reversion.type() == ParamType::Constant) {
        QL_REQUIRE(reversion.values().size() == 1, "reversion grid size 1 expected");
        QL_REQUIRE(reversion.times().size() == 0, "empty reversion time grid expected");
    } else if (reversion.type() == ParamType::Piecewise) {
        if (reversion.calibrate() && data_->calibrationType() == CalibrationType::Bootstrap) {
            if (reversion.times().size() > 0) {
                DLOG("overriding H time grid with option expiries");
            }
            QL_REQUIRE(optionExpiries_.size() > 0, "empty option expiries");
            hTimes = Array(optionExpiries_.begin(), optionExpiries_.end() - 1);
            h = Array(hTimes.size() + 1, reversion.values()[0]);
        } else { // use input time grid and input alpha array otherwise
            QL_REQUIRE(h.size() == hTimes.size() + 1, "H grids do not match");
        }
    } else {
        QL_FAIL("Expected DK model data reversion parameter to be Constant or Piecewise.");
    }
 
    DLOG("before calibration: alpha times = " << aTimes << " values = " << alpha);
    DLOG("before calibration:     h times = " << hTimes << " values = " << h)
 
    if (reversion.reversionType() == LgmData::ReversionType::HullWhite &&
        volatility.volatilityType() == LgmData::VolatilityType::HullWhite) {
        DLOG("INF parametrization: InfDkPiecewiseConstantHullWhiteAdaptor");
        parametrization_ = QuantLib::ext::make_shared<InfDkPiecewiseConstantHullWhiteAdaptor>(
            inflationIndex_->currency(), inflationIndex_->zeroInflationTermStructure(), aTimes, alpha, hTimes, h,
            data_->index());
    } else if (reversion.reversionType() == LgmData::ReversionType::HullWhite) {
        DLOG("INF parametrization for " << data_->index() << ": InfDkPiecewiseConstant");
        parametrization_ = QuantLib::ext::make_shared<InfDkPiecewiseConstantParametrization>(
            inflationIndex_->currency(), inflationIndex_->zeroInflationTermStructure(), aTimes, alpha, hTimes, h,
            data_->index());
    } else {
        parametrization_ = QuantLib::ext::make_shared<InfDkPiecewiseLinearParametrization>(
            inflationIndex_->currency(), inflationIndex_->zeroInflationTermStructure(), aTimes, alpha, hTimes, h,
            data_->index());
        DLOG("INF parametrization for " << data_->index() << ": InfDkPiecewiseLinear");
    }
 
    DLOG("alpha times size: " << aTimes.size());
    DLOG("lambda times size: " << hTimes.size());
 
    DLOG("Apply shift horizon and scale");
    Time horizon = data_->reversionTransformation().horizon();
    Real scaling = data_->reversionTransformation().scaling();
    QL_REQUIRE(horizon >= 0.0, "shift horizon must be non negative");
    QL_REQUIRE(scaling > 0.0, "scaling must be positive");
 
    if (horizon > 0.0) {
        DLOG("Apply shift horizon " << horizon << " to the " << data_->index() << " DK model");
        parametrization_->shift() = horizon;
    }
 
    if (scaling != 1.0) {
        DLOG("Apply scaling " << scaling << " to the " << data_->index() << " DK model");
        parametrization_->scaling() = scaling;
    }
}

Here is the call graph for this function:

Member Function Documentation

infIndex()

std::string infIndex

(

)

Definition at line 63 of file infdkbuilder.hpp.

{ return data_->index(); }

parametrization()

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

(

)

const

Definition at line 166 of file infdkbuilder.cpp.

                                                                                        {
    calculate();
    return parametrization_;
}

optionBasket()

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

(

)

const

Definition at line 171 of file infdkbuilder.cpp.

                                                                                          {
    calculate();
    return optionBasket_;
}

forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 387 of file infdkbuilder.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 176 of file infdkbuilder.cpp.

                                               {
    return (data_->volatility().calibrate() || data_->reversion().calibrate()) &&
           (volSurfaceChanged(false) || marketObserver_->hasUpdated(false) || forceCalibration_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setCalibrationDone()

void setCalibrationDone

(

)

const

Definition at line 188 of file infdkbuilder.cpp.

                                            {
    // reset market observer updated flag
    marketObserver_->hasUpdated(true);
    // update vol cache
    volSurfaceChanged(true);
}

Here is the call graph for this function:

performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 181 of file infdkbuilder.cpp.

                                             {
    if (requiresRecalibration()) {
        // build option basket
        buildCapFloorBasket();
    }
}

Here is the call graph for this function:

optionStrikeValue()

Real optionStrikeValue ( const Size  j ) const

private

Definition at line 208 of file infdkbuilder.cpp.

                                                       {
    const auto& ci = data_->calibrationBaskets()[0].instruments();
    QL_REQUIRE(j < ci.size(), "InfDkBuilder::optionMaturityDate(" << j << "): out of bounds, got " << ci.size()
                                                                  << " calibration instruments");
    auto cf = QuantLib::ext::dynamic_pointer_cast<CpiCapFloor>(ci.at(j));
    QL_REQUIRE(cf,
               "InfDkBuilder::optionStrike(" << j << "): expected CpiCapFloor calibration instruments, could not cast");
    return cpiCapFloorStrikeValue(cf->strike(), *inflationIndex_->zeroInflationTermStructure(), optionMaturityDate(j));
}

Here is the call graph for this function:

Here is the caller graph for this function:

optionMaturityDate()

Date optionMaturityDate ( const Size  j ) const

private

Definition at line 195 of file infdkbuilder.cpp.

                                                        {
    Date today = Settings::instance().evaluationDate();
    const auto& ci = data_->calibrationBaskets()[0].instruments();
    QL_REQUIRE(j < ci.size(), "InfDkBuilder::optionMaturityDate(" << j << "): out of bounds, got " << ci.size()
                                                                  << " calibration instruments");
    auto cf = QuantLib::ext::dynamic_pointer_cast<CpiCapFloor>(ci.at(j));
    QL_REQUIRE(cf, "InfDkBuilder::optionMaturityDate("
                       << j << "): expected CpiCapFloor calibration instruments, could not cast");
    Date res = optionMaturity(cf->maturity(), inflationIndex_->fixingCalendar());
    QL_REQUIRE(res > today, "expired calibration option expiry " << io::iso_date(res));
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildCapFloorBasket()

void buildCapFloorBasket ( ) const

private

Definition at line 276 of file infdkbuilder.cpp.

                                             {
 
    // Checks that there is a basket.
    QL_REQUIRE(!data_->calibrationBaskets().empty(), "No calibration basket provided in inflation DK model data.");
    const CalibrationBasket& cb = data_->calibrationBaskets()[0];
    const auto& ci = cb.instruments();
 
    QL_REQUIRE(ci.size() == optionActive_.size(), "Expected the option active vector size to equal the "
                                                      << "number of calibration instruments");
    fill(optionActive_.begin(), optionActive_.end(), false);
 
    DLOG("build reference date grid '" << referenceCalibrationGrid_ << "'");
    Date lastRefCalDate = Date::minDate();
    std::vector<Date> referenceCalibrationDates;
    if (!referenceCalibrationGrid_.empty())
        referenceCalibrationDates = DateGrid(referenceCalibrationGrid_).dates();
 
    QuantLib::ext::shared_ptr<QuantExt::CPICapFloorEngine> engine;
 
    bool isLogNormalVol = QuantExt::ZeroInflation::isCPIVolSurfaceLogNormal(infVol_.currentLink());
    if (isLogNormalVol) {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBlackCapFloorEngine>(rateCurve_, infVol_);
    } else {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBachelierCapFloorEngine>(rateCurve_, infVol_);
    }
       
    Calendar fixCalendar = inflationIndex_->fixingCalendar();
    Date baseDate = inflationIndex_->zeroInflationTermStructure()->baseDate();
    Real baseCPI = dontCalibrate_ ? 100. : inflationIndex_->fixing(baseDate);
    BusinessDayConvention bdc = infVol_->businessDayConvention();
    Period lag = infVol_->observationLag();
    Handle<ZeroInflationIndex> hIndex(inflationIndex_);
    Date startDate = Settings::instance().evaluationDate();
    bool useInterpolatedCPIFixings = infVol_->indexIsInterpolated();
    Real nominal = 1.0;
    vector<Time> expiryTimes;
    optionBasket_.clear();
    for (Size j = 0; j < ci.size(); j++) {
 
        auto cpiCapFloor = QuantLib::ext::dynamic_pointer_cast<CpiCapFloor>(ci[j]);
        QL_REQUIRE(cpiCapFloor, "Expected CpiCapFloor calibration instruments in DK inflation model data.");
 
        Date expiryDate = optionMaturityDate(j);
 
        // check if we want to keep the helper when a reference calibration grid is given
        auto refCalDate =
            std::lower_bound(referenceCalibrationDates.begin(), referenceCalibrationDates.end(), expiryDate);
        if (refCalDate == referenceCalibrationDates.end() || *refCalDate > lastRefCalDate) {
            Real strikeValue = optionStrikeValue(j);
            Option::Type capfloor = cpiCapFloor->type() == CapFloor::Cap ? Option::Call : Option::Put;
            QuantLib::ext::shared_ptr<CPICapFloor> cf =
                QuantLib::ext::make_shared<CPICapFloor>(capfloor, nominal, startDate, baseCPI, expiryDate, fixCalendar, bdc,
                                                fixCalendar, bdc, strikeValue, inflationIndex_, lag);
            cf->setPricingEngine(engine);
            Real tte = inflationYearFraction(inflationIndex_->frequency(), useInterpolatedCPIFixings,
                                             inflationIndex_->zeroInflationTermStructure()->dayCounter(), baseDate,
                                             cf->fixingDate());
 
            Real tteFromBase = infVol_->timeFromBase(expiryDate);
 
            Real marketPrem;
            if (dontCalibrate_)
                marketPrem = 0.1;
            else if (tte <= 0 || tteFromBase <= 0)
                marketPrem = 0.00;
            else
                marketPrem = cf->NPV();
 
            QuantLib::ext::shared_ptr<QuantExt::CpiCapFloorHelper> helper =
                QuantLib::ext::make_shared<QuantExt::CpiCapFloorHelper>(capfloor, baseCPI, expiryDate, fixCalendar, bdc,
                                                                        fixCalendar, bdc, strikeValue, hIndex, lag,
                                                                        marketPrem);
 
            // we might produce duplicate expiry times even if the fixing dates are all different
            if (marketPrem > 0.0 && tte > 0 && tteFromBase > 0 &&
                std::find_if(expiryTimes.begin(), expiryTimes.end(),
                             [tte](Real x) { return QuantLib::close_enough(x, tte); }) == expiryTimes.end()) {
                optionBasket_.push_back(helper);
                helper->performCalculations();
                expiryTimes.push_back(tte);
                DLOG("Added InflationOptionHelper index="
                     << data_->index() << ", type=" << (capfloor == Option::Type::Call ? "Cap" : "Floor") << ", expiry="
                     << QuantLib::io::iso_date(expiryDate) << ", baseCPI=" << baseCPI << ", strike=" << strikeValue
                     << ", lag=" << lag << ", marketPremium=" << marketPrem << ", tte=" << tte);
                optionActive_[j] = true;
                if (refCalDate != referenceCalibrationDates.end())
                    lastRefCalDate = *refCalDate;
            } else {
                if (data_->ignoreDuplicateCalibrationExpiryTimes()) {
                    DLOG("Skipped InflationOptionHelper index="
                         << data_->index() << ", type=" << (capfloor == Option::Type::Call ? "Cap" : "Floor")
                         << ", expiry=" << QuantLib::io::iso_date(expiryDate) << ", baseCPI=" << baseCPI
                         << ", strike=" << strikeValue << ", lag=" << lag << ", marketPremium=" << marketPrem
                         << ", tte=" << tte << " since we already have a helper with the same expiry time.");
                } else {
                    QL_FAIL("InfDkBuilder: a CPI cap floor calibration instrument with the expiry time, "
                            << tte << ", was already added.");
                }
            }
        }
    }
 
    std::sort(expiryTimes.begin(), expiryTimes.end());
    auto itExpiryTime = unique(expiryTimes.begin(), expiryTimes.end());
    expiryTimes.resize(distance(expiryTimes.begin(), itExpiryTime));
 
    optionExpiries_ = Array(expiryTimes.size());
    for (Size j = 0; j < expiryTimes.size(); j++)
        optionExpiries_[j] = expiryTimes[j];
}

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 218 of file infdkbuilder.cpp.

                                                                 {
    bool hasUpdated = false;
    if(dontCalibrate_)
        return false;
 
    QuantLib::ext::shared_ptr<QuantExt::CPICapFloorEngine> engine;
 
    bool isLogNormalVol = QuantExt::ZeroInflation::isCPIVolSurfaceLogNormal(infVol_.currentLink());
    if (isLogNormalVol) {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBlackCapFloorEngine>(rateCurve_, infVol_);
    } else {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBachelierCapFloorEngine>(rateCurve_, infVol_);
    }
 
    Calendar fixCalendar = inflationIndex_->fixingCalendar();
    BusinessDayConvention bdc = infVol_->businessDayConvention();
    Date baseDate = inflationIndex_->zeroInflationTermStructure()->baseDate();
    Real baseCPI = inflationIndex_->fixing(baseDate);
    Period lag = infVol_->observationLag();
 
    // if cache doesn't exist resize vector
    if (infPriceCache_.size() != optionBasket_.size())
        infPriceCache_ = vector<Real>(optionBasket_.size(), Null<Real>());
 
    // Handle on calibration instruments. No checks this time.
    const auto& ci = data_->calibrationBaskets()[0].instruments();
 
    Real nominal = 1.0;
    Size optionCounter = 0;
    Date today = Settings::instance().evaluationDate();
    for (Size j = 0; j < ci.size(); j++) {
 
        if (!optionActive_[j])
            continue;
 
        auto cpiCapFloor = QuantLib::ext::dynamic_pointer_cast<CpiCapFloor>(ci[j]);
        QL_REQUIRE(cpiCapFloor, "Expected CpiCapFloor calibration instruments in DK inflation model data.");
 
        Date expiryDate = optionMaturityDate(j);
        auto strikeValue = optionStrikeValue(j);
 
        Option::Type capfloor = cpiCapFloor->type() == CapFloor::Cap ? Option::Call : Option::Put;
 
        QuantLib::ext::shared_ptr<CPICapFloor> h =
            QuantLib::ext::make_shared<CPICapFloor>(capfloor, nominal, today, baseCPI, expiryDate, fixCalendar, bdc,
                                            fixCalendar, bdc, strikeValue, inflationIndex_, lag);
        h->setPricingEngine(engine);
        Real price = h->NPV();
        if (!close_enough(infPriceCache_[optionCounter], price)) {
            if (updateCache)
                infPriceCache_[optionCounter] = price;
            hasUpdated = true;
        }
        optionCounter++;
    }
    return hasUpdated;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

market_

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

private

Definition at line 86 of file infdkbuilder.hpp.

configuration_

const std::string configuration_

private

Definition at line 87 of file infdkbuilder.hpp.

data_

const QuantLib::ext::shared_ptr<InfDkData> data_

private

Definition at line 88 of file infdkbuilder.hpp.

referenceCalibrationGrid_

const std::string referenceCalibrationGrid_

private

Definition at line 89 of file infdkbuilder.hpp.

parametrization_

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

private

Definition at line 92 of file infdkbuilder.hpp.

optionActive_

std::vector<bool> optionActive_

mutableprivate

Definition at line 95 of file infdkbuilder.hpp.

optionBasket_

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

mutableprivate

Definition at line 96 of file infdkbuilder.hpp.

optionExpiries_

QuantLib::Array optionExpiries_

mutableprivate

Definition at line 97 of file infdkbuilder.hpp.

inflationIndex_

QuantLib::ext::shared_ptr<QuantLib::ZeroInflationIndex> inflationIndex_

private

Definition at line 100 of file infdkbuilder.hpp.

rateCurve_

Handle<YieldTermStructure> rateCurve_

private

Definition at line 101 of file infdkbuilder.hpp.

infVol_

QuantLib::Handle<QuantLib::CPIVolatilitySurface> infVol_

private

Definition at line 102 of file infdkbuilder.hpp.

infPriceCache_

std::vector<QuantLib::Real> infPriceCache_

mutableprivate

Definition at line 105 of file infdkbuilder.hpp.

forceCalibration_

bool forceCalibration_ = false

private

Definition at line 108 of file infdkbuilder.hpp.

dontCalibrate_

bool dontCalibrate_ = false

private

Definition at line 111 of file infdkbuilder.hpp.

marketObserver_

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

private

Definition at line 114 of file infdkbuilder.hpp.