InfJyBuilder Class Reference

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

Inheritance diagram for InfJyBuilder:

Collaboration diagram for InfJyBuilder:

Public Types
using	Helpers = std::vector< QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > >

Public Member Functions
	InfJyBuilder (const QuantLib::ext::shared_ptr< Market > &market, const QuantLib::ext::shared_ptr< InfJyData > &data, const std::string &configuration=Market::defaultConfiguration, const std::string &referenceCalibrationGrid="", const bool donCalibrate=false)
Inspectors
std::string	inflationIndex () const
QuantLib::ext::shared_ptr< QuantExt::InfJyParameterization >	parameterization () const
Helpers	realRateBasket () const
Helpers	indexBasket () const
Public Member Functions inherited from ModelBuilder
void	recalibrate () const
virtual void	forceRecalculate ()
virtual bool	requiresRecalibration () const=0

Private Member Functions
LazyObject interface
void	performCalculations () const override
void	buildCalibrationBaskets () const
	Build any calibration baskets requested by the configuration i.e. via the data_ member. More...
Helpers	buildCalibrationBasket (const CalibrationBasket &cb, std::vector< bool > &active, QuantLib::Array &expiries, bool forRealRateReversion=false) const
	Build the calibration basket. More...
Helpers	buildCpiCapFloorBasket (const CalibrationBasket &cb, std::vector< bool > &active, QuantLib::Array &expiries) const
	Build a CPI cap floor calibration basket. More...
Helpers	buildYoYCapFloorBasket (const CalibrationBasket &cb, std::vector< bool > &active, QuantLib::Array &expiries) const
	Build a YoY cap floor calibration basket. More...
Helpers	buildYoYSwapBasket (const CalibrationBasket &cb, std::vector< bool > &active, QuantLib::Array &expiries, bool forRealRateReversion=false) const
	Build a YoY swap calibration basket. More...
const CalibrationBasket &	calibrationBasket (const std::string &parameter) const
	Find calibration basket with parameter value equal to parameter. More...
QuantLib::ext::shared_ptr< QuantExt::Lgm1fParametrization< ZeroInflationTermStructure > >	createRealRateParam () const
	Create the real rate parameterisation. More...
QuantLib::ext::shared_ptr< QuantExt::FxBsParametrization >	createIndexParam () const
	Create the inflation index parameterisation. More...
void	setupParams (const ModelParameter &param, QuantLib::Array &times, QuantLib::Array &values, const QuantLib::Array &expiries, const std::string &paramName) const
std::vector< QuantLib::Date >	referenceCalibrationDates () const
	Create the reference calibration dates. More...
void	initialiseMarket ()
	Attempt to initialise market data members that may be needed for building calibration instruments. More...
bool	pricesChanged (bool updateCache) const
QuantLib::Real	marketPrice (const QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > &helper) const
	Return the market value of the given calibration helper. More...

ModelBuilder interface
QuantLib::ext::shared_ptr< Market >	market_
std::string	configuration_
QuantLib::ext::shared_ptr< InfJyData >	data_
std::string	referenceCalibrationGrid_
bool	dontCalibrate_
QuantLib::ext::shared_ptr< QuantExt::InfJyParameterization >	parameterization_
QuantLib::ext::shared_ptr< QuantExt::MarketObserver >	marketObserver_
Handle< YieldTermStructure >	rateCurve_
QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex >	zeroInflationIndex_
QuantLib::Handle< QuantLib::CPIVolatilitySurface >	cpiVolatility_
QuantLib::ext::shared_ptr< QuantLib::YoYInflationIndex >	yoyInflationIndex_
QuantLib::Handle< QuantLib::YoYOptionletVolatilitySurface >	yoyVolatility_
bool	forceCalibration_ = false
Helpers	realRateBasket_
std::vector< bool >	rrInstActive_
QuantLib::Array	rrInstExpiries_
Helpers	indexBasket_
std::vector< bool >	indexInstActive_
QuantLib::Array	indexInstExpiries_
std::vector< QuantLib::Real >	priceCache_
	Cache the prices of all of the active calibration helper instruments. More...
void	forceRecalculate () override
bool	requiresRecalibration () const override
void	setCalibrationDone () const

Detailed Description

Builder for a Jarrow Yildrim inflation model component

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

Definition at line 42 of file infjybuilder.hpp.

Member Typedef Documentation

Helpers

using Helpers = std::vector<QuantLib::ext::shared_ptr<QuantLib::CalibrationHelper> >

Definition at line 54 of file infjybuilder.hpp.

Constructor & Destructor Documentation

InfJyBuilder()

InfJyBuilder	(	const QuantLib::ext::shared_ptr< Market > &	market,
		const QuantLib::ext::shared_ptr< InfJyData > &	data,
		const std::string &	configuration = Market::defaultConfiguration,
		const std::string &	referenceCalibrationGrid = "",
		const bool	donCalibrate = false
	)

Constructor

Parameters

market	Market object
data	Jarrow Yildrim inflation model description
configuration	Market configuration to use
referenceCalibrationGrid	The reference calibration grid

Definition at line 77 of file infjybuilder.cpp.

    : market_(market), configuration_(configuration), data_(data), referenceCalibrationGrid_(referenceCalibrationGrid),
      dontCalibrate_(dontCalibrate), marketObserver_(QuantLib::ext::make_shared<MarketObserver>()),
      zeroInflationIndex_(*market_->zeroInflationIndex(data_->index(), configuration_)) {
 
    LOG("InfJyBuilder: building model for inflation index " << data_->index());
 
    // Get rate curve
    rateCurve_ = market_->discountCurve(zeroInflationIndex_->currency().code(), configuration_);
 
    // Register with market observables except volatilities
    marketObserver_->registerWith(zeroInflationIndex_);
    marketObserver_->registerWith(rateCurve_);
    initialiseMarket();
 
    // Register the model builder with the market observer
    registerWith(marketObserver_);
 
    // Notify observers of all market data changes, not only when not calculated
    alwaysForwardNotifications();
 
    // Build the calibration instruments
    buildCalibrationBaskets();
 
    // Create the JY parameterisation.
    parameterization_ = QuantLib::ext::make_shared<QuantExt::InfJyParameterization>(
        createRealRateParam(), createIndexParam(), zeroInflationIndex_);
}

Here is the call graph for this function:

Member Function Documentation

inflationIndex()

string inflationIndex

(

)

const

Definition at line 108 of file infjybuilder.cpp.

                                          {
    return data_->index();
}

Here is the caller graph for this function:

parameterization()

QuantLib::ext::shared_ptr< QuantExt::InfJyParameterization > parameterization

(

)

const

Definition at line 112 of file infjybuilder.cpp.

                                                                                          {
    calculate();
    return parameterization_;
}

realRateBasket()

Helpers realRateBasket

(

)

const

Definition at line 117 of file infjybuilder.cpp.

                                           {
    calculate();
    return realRateBasket_;
}

indexBasket()

Helpers indexBasket

(

)

const

Definition at line 122 of file infjybuilder.cpp.

                                        {
    calculate();
    return indexBasket_;
}

forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 144 of file infjybuilder.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 127 of file infjybuilder.cpp.

                                               {
    return (data_->realRateVolatility().calibrate() || data_->realRateReversion().calibrate() ||
            data_->indexVolatility().calibrate()) &&
           (marketObserver_->hasUpdated(false) || forceCalibration_ || pricesChanged(false));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setCalibrationDone()

void setCalibrationDone

(

)

const

Definition at line 139 of file infjybuilder.cpp.

                                            {
    marketObserver_->hasUpdated(true);
    pricesChanged(true);
}

Here is the call graph for this function:

performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 133 of file infjybuilder.cpp.

                                             {
    if (requiresRecalibration()) {
        buildCalibrationBaskets();
    }
}

Here is the call graph for this function:

buildCalibrationBaskets()

void buildCalibrationBaskets ( ) const

private

Build any calibration baskets requested by the configuration i.e. via the data_ member.

Definition at line 150 of file infjybuilder.cpp.

                                                 {
 
    // If calibration type is None, don't build any baskets.
    if (data_->calibrationType() == CalibrationType::None) {
        DLOG("InfJyBuilder: calibration type is None so no calibration baskets built.");
        return;
    }
 
    const auto& cbs = data_->calibrationBaskets();
 
    // If calibration type is BestFit, check that we have at least one calibration basket. Build up to a maximum of 
    // two calibration baskets. Log a warning if more than two are given. Arbitrarily assign the built baskets to 
    // the realRateBasket_ and indexBasket_ members. They will be combined again in any case for BestFit calibration.
    if (data_->calibrationType() == CalibrationType::BestFit) {
        QL_REQUIRE(cbs.size() > 0, "InfJyBuilder: calibration type is BestFit but no calibration baskets provided.");
        rrInstActive_ = vector<bool>(cbs[0].instruments().size(), false);
        realRateBasket_ = buildCalibrationBasket(cbs[0], rrInstActive_, rrInstExpiries_);
        if (cbs.size() > 1) {
            indexInstActive_ = vector<bool>(cbs[1].instruments().size(), false);
            indexBasket_ = buildCalibrationBasket(cbs[1], indexInstActive_, indexInstExpiries_);
        }
        if (cbs.size() > 2)
            WLOG("InfJyBuilder: only 2 calibration baskets can be processed but " << cbs.size() <<
                " were supplied. The extra baskets are ignored.");
        return;
    }
 
    // Make sure that the calibration type is now Bootstrap.
    QL_REQUIRE(data_->calibrationType() == CalibrationType::Bootstrap, "InfJyBuilder: expected the calibration " <<
        "type to be one of None, BestFit or Bootstrap.");
 
    const VolatilityParameter& idxVolatility = data_->indexVolatility();
    const ReversionParameter& rrReversion = data_->realRateReversion();
    const VolatilityParameter& rrVolatility = data_->realRateVolatility();
 
    // Firstly, look at the inflation index portion i.e. are we calibrating it.
    if (idxVolatility.calibrate()) {
 
        DLOG("InfJyBuilder: building calibration basket for JY index bootstrap calibration.");
 
        // If we are not calibrating the real rate portion, then we expect exactly one calibration basket. Otherwise 
        // we need to find a basket with the 'Index' parameter.
        if (!rrReversion.calibrate() && !rrVolatility.calibrate()) {
            QL_REQUIRE(cbs.size() == 1, "InfJyBuilder: calibrating only JY index volatility using Bootstrap so " <<
                "expected exactly one basket but got " << cbs.size() << ".");
            const auto& cb = cbs[0];
            if (!cb.parameter().empty() && cb.parameter() != "Index") {
                WLOG("InfJyBuilder: calibrating only JY index volatility using Bootstrap so expected the " <<
                    "calibration basket parameter to be 'Index' but got '" << cb.parameter() << "'.");
            }
            indexInstActive_ = vector<bool>(cb.instruments().size(), false);
            indexBasket_ = buildCalibrationBasket(cb, indexInstActive_, indexInstExpiries_);
        } else {
            DLOG("InfJyBuilder: need a calibration basket with parameter equal to 'Index'.");
            const auto& cb = calibrationBasket("Index");
            indexInstActive_ = vector<bool>(cb.instruments().size(), false);
            indexBasket_ = buildCalibrationBasket(cb, indexInstActive_, indexInstExpiries_);
        }
    }
 
    // Secondly, look at the real rate portion i.e. are we calibrating it.
    if (rrReversion.calibrate() || rrVolatility.calibrate()) {
 
        DLOG("InfJyBuilder: building calibration basket for JY real rate bootstrap calibration.");
        QL_REQUIRE(!(rrReversion.calibrate() && rrVolatility.calibrate()), "InfJyBuilder: calibrating both the " <<
            "real rate reversion and real rate volatility using Bootstrap is not supported.");
 
        // If we are not calibrating the index portion, then we expect exactly one calibration basket. Otherwise 
        // we need to find a basket with the 'RealRate' parameter.
        if (!idxVolatility.calibrate()) {
            QL_REQUIRE(cbs.size() == 1, "InfJyBuilder: calibrating only JY real rate using Bootstrap so " <<
                "expected exactly one basket but got " << cbs.size() << ".");
            const auto& cb = cbs[0];
            if (!cb.parameter().empty() && cb.parameter() != "RealRate") {
                WLOG("InfJyBuilder: calibrating only JY real rate using Bootstrap so expected the " <<
                    "calibration basket parameter to be 'RealRate' but got '" << cb.parameter() << "'.");
            }
            rrInstActive_ = vector<bool>(cb.instruments().size(), false);
            realRateBasket_ = buildCalibrationBasket(cb, rrInstActive_, rrInstExpiries_, rrReversion.calibrate());
        } else {
            DLOG("InfJyBuilder: need a calibration basket with parameter equal to 'RealRate'.");
            const auto& cb = calibrationBasket("RealRate");
            rrInstActive_ = vector<bool>(cb.instruments().size(), false);
            realRateBasket_ = buildCalibrationBasket(cb, rrInstActive_, rrInstExpiries_, rrReversion.calibrate());
        }
    }
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildCalibrationBasket()

Helpers buildCalibrationBasket ( const CalibrationBasket &  cb, std::vector< bool > &  active, QuantLib::Array &  expiries, bool  forRealRateReversion = false  ) const

private

Build the calibration basket.

Definition at line 239 of file infjybuilder.cpp.

                                                                            {
 
    QL_REQUIRE(!cb.empty(), "InfJyBuilder: calibration basket should not be empty.");
 
    const auto& ci = cb.instruments();
    QL_REQUIRE(ci.size() == active.size(), "InfJyBuilder: expected the active instruments vector " <<
        "size to equal the number of calibration instruments");
    fill(active.begin(), active.end(), false);
 
    if (cb.instrumentType() == "CpiCapFloor") {
        return buildCpiCapFloorBasket(cb, active, expiries);
    } else if (cb.instrumentType() == "YoYCapFloor") {
        return buildYoYCapFloorBasket(cb, active, expiries);
    } else if (cb.instrumentType() == "YoYSwap") {
        return buildYoYSwapBasket(cb, active, expiries, forRealRateReversion);
    } else {
        QL_FAIL("InfJyBuilder: expected calibration instrument to be one of CpiCapFloor, YoYCapFloor or YoYSwap");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildCpiCapFloorBasket()

Helpers buildCpiCapFloorBasket ( const CalibrationBasket &  cb, std::vector< bool > &  active, QuantLib::Array &  expiries  ) const

private

Build a CPI cap floor calibration basket.

Definition at line 260 of file infjybuilder.cpp.

                                                 {
 
    DLOG("InfJyBuilder: start building the CPI cap floor calibration basket.");
 
    QL_REQUIRE(!cpiVolatility_.empty(), "InfJyBuilder: need a non-empty CPI cap floor volatility structure " <<
        "to build a CPI cap floor calibration basket.");
 
    // Procedure is to create a CPI cap floor as described by each instrument in the calibration basket. We then value 
    // each of the CPI cap floor instruments using market data and an engine and pass the NPV as the market premium to 
    // helper that we create.
 
    Helpers helpers;
 
    // Create the engine
    auto zts = zeroInflationIndex_->zeroInflationTermStructure();
    
    QuantLib::ext::shared_ptr<QuantExt::CPICapFloorEngine> engine;
    bool isLogNormalVol = QuantExt::ZeroInflation::isCPIVolSurfaceLogNormal(cpiVolatility_.currentLink());
    if (isLogNormalVol) {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBlackCapFloorEngine>(rateCurve_, cpiVolatility_);
    } else {
        engine = QuantLib::ext::make_shared<QuantExt::CPIBachelierCapFloorEngine>(rateCurve_, cpiVolatility_);
    }
    // CPI cap floor calibration instrument details. Assumed to equal those from the index and market structures.
    // Some of these should possibly come from conventions.
    // Also some variables used in the loop below.
    auto calendar = zeroInflationIndex_->fixingCalendar();
    auto baseDate = zts->baseDate();
    auto baseCpi = dontCalibrate_ ? 100.0 : zeroInflationIndex_->fixing(baseDate);
    auto bdc = cpiVolatility_->businessDayConvention();
    auto obsLag = cpiVolatility_->observationLag();
    
    Handle<ZeroInflationIndex> inflationIndex(zeroInflationIndex_);
    Date today = Settings::instance().evaluationDate();
    Real nominal = 1.0;
 
    // Avoid instruments with duplicate expiry times in the loop below
    set<Time, CloseCmp> expiryTimes;
 
    // Reference calibration dates if any. If they are given, we only include one calibration instrument from each 
    // period in the grid. Logic copied from other builders.
    auto rcDates = referenceCalibrationDates();
    auto prevRcDate = Date::minDate();
 
    // Add calibration instruments to the helpers vector.
    const auto& ci = cb.instruments();
 
    auto observationInterpolation = cpiVolatility_->indexIsInterpolated() ? CPI::Linear : CPI::Flat;
 
    for (Size i = 0; i < ci.size(); ++i) {
 
        auto cpiCapFloor = QuantLib::ext::dynamic_pointer_cast<CpiCapFloor>(ci[i]);
        QL_REQUIRE(cpiCapFloor, "InfJyBuilder: expected CpiCapFloor calibration instrument.");
        auto maturity = optionMaturity(cpiCapFloor->maturity(), calendar);
 
        // Deal with reference calibration date grid stuff.
        auto rcDate = lower_bound(rcDates.begin(), rcDates.end(), maturity);
        if (!(rcDate == rcDates.end() || *rcDate > prevRcDate)) {
            active[i] = false;
            continue;
        }
 
        if (rcDate != rcDates.end())
            prevRcDate = *rcDate;
 
        // Build the CPI calibration instrument in order to calculate its NPV.
 
        /* FIXME - the maturity date is not adjusted on eval date changes even if given as a tenor
                 - if the strike is atm, the value will not be updated on eval date changes */
        Real strikeValue =
            cpiCapFloorStrikeValue(cpiCapFloor->strike(), *zeroInflationIndex_->zeroInflationTermStructure(), maturity);
        Option::Type capfloor = cpiCapFloor->type() == CapFloor::Cap ? Option::Call : Option::Put;
        auto inst = QuantLib::ext::make_shared<CPICapFloor>(capfloor, nominal, today, baseCpi, maturity, calendar, bdc, calendar, bdc,
                                            strikeValue, zeroInflationIndex_, obsLag, observationInterpolation);
        inst->setPricingEngine(engine);
 
        auto fixingDate = inst->fixingDate();
        auto t = inflationTime(fixingDate, *zts, false);
 
        // Build the helper using the NPV as the premium.
        Real premium;
        if(dontCalibrate_)
            premium = 0.01;
        else if(t <= 0.0)
            premium = 0.0;
        else
            premium = inst->NPV();
 
        auto helper = QuantLib::ext::make_shared<CpiCapFloorHelper>(capfloor, baseCpi, maturity, calendar, bdc, calendar, bdc,
                                                            strikeValue, inflationIndex, obsLag, premium,
                                                            observationInterpolation);
 
        // if time is not positive or market prem is zero deactivate helper
        if (t < 0.0 || QuantLib::close_enough(t, 0.0) || QuantLib::close_enough(premium, 0.0)) {
            active[i] = false;
            continue;
        }
 
        auto p = expiryTimes.insert(t);
        QL_REQUIRE(data_->ignoreDuplicateCalibrationExpiryTimes() || p.second,
                   "InfJyBuilder: a CPI cap floor calibration "
                       << "instrument with the expiry time, " << t << ", was already added.");
 
        if(p.second)
            helpers.push_back(helper);
 
        TLOG("InfJyBuilder: " << (p.second ?
                                  "added CPICapFloor helper" :
                                  "skipped CPICapFloor helper due to duplicate expiry time (" + std::to_string(t) + ")") <<
             ": index = " << data_->index() <<
             ", type = " << cpiCapFloor->type() <<
             ", expiry = " << io::iso_date(maturity) <<
             ", base CPI = " << baseCpi <<
             ", strike = " << strikeValue <<
             ", obs lag = " << obsLag <<
             ", market premium = " << premium);
    }
 
    // Populate the expiry times array with the unique sorted expiry times.
    expiries = Array(expiryTimes.begin(), expiryTimes.end());
 
    DLOG("InfJyBuilder: finished building the CPI cap floor calibration basket.");
 
    return helpers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildYoYCapFloorBasket()

Helpers buildYoYCapFloorBasket ( const CalibrationBasket &  cb, std::vector< bool > &  active, QuantLib::Array &  expiries  ) const

private

Build a YoY cap floor calibration basket.

Definition at line 387 of file infjybuilder.cpp.

                                                                                                                     {
 
    DLOG("InfJyBuilder: start building the YoY cap floor calibration basket.");
 
    // Initial checks.
    QL_REQUIRE(yoyInflationIndex_, "InfJyBuilder: need a valid year on year inflation index "
                                       << "to build a year on year cap floor calibration basket.");
    auto yoyTs = yoyInflationIndex_->yoyInflationTermStructure();
    QL_REQUIRE(!yoyTs.empty(), "InfJyBuilder: need a valid year on year term structure "
                                   << "to build a year on year cap floor calibration basket.");
    QL_REQUIRE(!yoyVolatility_.empty(), "InfJyBuilder: need a valid year on year volatility "
                                            << "structure to build a year on year cap floor calibration basket.");
 
    // Procedure is to create a YoY cap floor as described by each instrument in the calibration basket. We then value
    // each of the YoY cap floor instruments using market data and an engine and pass the NPV as the market premium to
    // helper that we create.
 
    Helpers helpers;
 
    // Create the engine which depends on the type of the YoY volatility and the shift.
    QuantLib::ext::shared_ptr<PricingEngine> engine;
    auto ovsType = yoyVolatility_->volatilityType();
    if (ovsType == Normal)
        engine = QuantLib::ext::make_shared<YoYInflationBachelierCapFloorEngine>(yoyInflationIndex_, yoyVolatility_, rateCurve_);
    else if (ovsType == ShiftedLognormal && close(yoyVolatility_->displacement(), 0.0))
        engine = QuantLib::ext::make_shared<YoYInflationBlackCapFloorEngine>(yoyInflationIndex_, yoyVolatility_, rateCurve_);
    else if (ovsType == ShiftedLognormal)
        engine =
            QuantLib::ext::make_shared<YoYInflationUnitDisplacedBlackCapFloorEngine>(yoyInflationIndex_, yoyVolatility_, rateCurve_);
    else
        QL_FAIL("InfJyBuilder: can't create engine with yoy volatility type, " << ovsType << ".");
 
    // YoY cap floor calibration instrument details. Assumed to equal those from the index and market structures.
    // Some of these should possibly come from conventions. Also some variables used in the loop below.
    Natural settlementDays = 2;
    auto calendar = yoyInflationIndex_->fixingCalendar();
    DayCounter dc = Thirty360(Thirty360::BondBasis);
    auto bdc = Following;
    auto obsLag = yoyVolatility_->observationLag();
 
    // Avoid instruments with duplicate expiry times in the loop below
    set<Time, CloseCmp> expiryTimes;
 
    // Reference calibration dates if any. If they are given, we only include one calibration instrument from each 
    // period in the grid. Logic copied from other builders.
    auto rcDates = referenceCalibrationDates();
    auto prevRcDate = Date::minDate();
 
    // Add calibration instruments to the helpers vector.
    const auto& ci = cb.instruments();
    for (Size i = 0; i < ci.size(); ++i) {
 
        auto yoyCapFloor = QuantLib::ext::dynamic_pointer_cast<YoYCapFloor>(ci[i]);
        QL_REQUIRE(yoyCapFloor, "InfJyBuilder: expected YoYCapFloor calibration instrument.");
 
        /*! Get the configured strike.
            FIXME If the strike is atm, the value will not be updated on evaluation date changes */
        Date today = Settings::instance().evaluationDate();
        Date maturityDate = calendar.advance(calendar.advance(today, settlementDays * Days), yoyCapFloor->tenor(), bdc);
        Real strikeValue = yoyCapFloorStrikeValue(yoyCapFloor->strike(), *yoyTs, maturityDate);
 
        // Build the YoY cap floor helper.
        auto quote = QuantLib::ext::make_shared<SimpleQuote>(0.01);
        auto helper = QuantLib::ext::make_shared<YoYCapFloorHelper>(Handle<Quote>(quote), yoyCapFloor->type(), strikeValue,
            settlementDays, yoyCapFloor->tenor(), yoyInflationIndex_, obsLag, calendar, bdc, dc, calendar, bdc);
 
        // Deal with reference calibration date grid stuff based on maturity of helper instrument.
        auto helperInst = helper->yoyCapFloor();
        auto maturity = helperInst->maturityDate();
        auto rcDate = lower_bound(rcDates.begin(), rcDates.end(), maturity);
        if (!(rcDate == rcDates.end() || *rcDate > prevRcDate)) {
            active[i] = false;
            continue;
        }
 
        if (rcDate != rcDates.end())
            prevRcDate = *rcDate;
 
        // Price the underlying helper instrument to get its fair premium.
        helperInst->setPricingEngine(engine);
 
        // Update the helper's market quote with the fair rate.
        quote->setValue(dontCalibrate_ ? 0.1 : helperInst->NPV());
 
        // Add the helper's time to expiry.
        auto fixingDate = helperInst->lastYoYInflationCoupon()->fixingDate();
        auto t = inflationTime(fixingDate, *yoyTs, yoyInflationIndex_->interpolated());
 
        // if time is not positive deactivate helper
        if (t < 0.0 || QuantLib::close_enough(t, 0.0)) {
            active[i] = false;
            continue;
        }
 
        auto p = expiryTimes.insert(t);
        QL_REQUIRE(data_->ignoreDuplicateCalibrationExpiryTimes() || p.second,
                   "InfJyBuilder: a YoY cap floor calibration "
                       << "instrument with the expiry time, " << t << ", was already added.");
 
        // Add the helper to the calibration helpers.
        if(p.second)
            helpers.push_back(helper);
 
        TLOG("InfJyBuilder: " << (p.second ?
                                  "added YoYCapFloor helper" :
                                  "skipped YoYCapFloor helper due to duplicate expiry time (" + std::to_string(t) + ")") <<
            ": index = " << data_->index() <<
            ", type = " << yoyCapFloor->type() <<
            ", expiry = " << io::iso_date(maturity) <<
            ", strike = " << strikeValue <<
            ", obs lag = " << obsLag <<
            ", market premium = " << quote->value());
    }
 
    // Populate the expiry times array with the unique sorted expiry times.
    expiries = Array(expiryTimes.begin(), expiryTimes.end());
 
    DLOG("InfJyBuilder: finished building the YoY cap floor calibration basket.");
 
    return helpers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildYoYSwapBasket()

Helpers buildYoYSwapBasket ( const CalibrationBasket &  cb, std::vector< bool > &  active, QuantLib::Array &  expiries, bool  forRealRateReversion = false  ) const

private

Build a YoY swap calibration basket.

Definition at line 509 of file infjybuilder.cpp.

                                                                            {
 
    DLOG("InfJyBuilder: start building the YoY swap calibration basket.");
 
    // Initial checks.
    QL_REQUIRE(yoyInflationIndex_, "InfJyBuilder: need a valid year on year inflation index " <<
        "to build a year on year swap calibration basket.");
    auto yoyTs = yoyInflationIndex_->yoyInflationTermStructure();
    QL_REQUIRE(!yoyTs.empty(), "InfJyBuilder: need a valid year on year term structure " <<
        "to build a year on year swap calibration basket.");
 
    // Procedure is to create a YoY cap floor as described by each instrument in the calibration basket. We then value 
    // each of the YoY cap floor instruments using market data and an engine and pass the NPV as the market premium to 
    // helper that we create.
 
    Helpers helpers;
 
    // Create the engine
    auto engine = QuantLib::ext::make_shared<DiscountingSwapEngine>(rateCurve_);
 
    // YoY swap calibration instrument details. Assumed to equal those from the index and market structures.
    // Some of these should possibly come from conventions. Hardcoded some common values here.
    // Also some variables used in the loop below.
    Natural settlementDays = 2;
    auto calendar = yoyInflationIndex_->fixingCalendar();
    auto dc = Thirty360(Thirty360::BondBasis);
    auto bdc = Following;
    auto obsLag = yoyTs->observationLag();
 
    // Avoid instruments with duplicate expiry times in the loop below
    set<Time, CloseCmp> expiryTimes;
 
    // Reference calibration dates if any. If they are given, we only include one calibration instrument from each 
    // period in the grid. Logic copied from other builders.
    auto rcDates = referenceCalibrationDates();
    auto prevRcDate = Date::minDate();
 
    // Add calibration instruments to the helpers vector.
    const auto& ci = cb.instruments();
    for (Size i = 0; i < ci.size(); ++i) {
 
        auto yoySwap = QuantLib::ext::dynamic_pointer_cast<YoYSwap>(ci[i]);
        QL_REQUIRE(yoySwap, "InfJyBuilder: expected YoYSwap calibration instrument.");
 
        // Build the YoY helper.
        auto quote = QuantLib::ext::make_shared<SimpleQuote>(0.01);
        auto helper = QuantLib::ext::make_shared<YoYSwapHelper>(Handle<Quote>(quote), settlementDays, yoySwap->tenor(),
                                                        yoyInflationIndex_, rateCurve_, obsLag, calendar, bdc, dc,
                                                        calendar, bdc, dc, calendar, bdc);
 
        // Deal with reference calibration date grid stuff based on maturity of helper instrument.
        auto helperInst = helper->yoySwap();
        auto maturity = helperInst->maturityDate();
        auto rcDate = lower_bound(rcDates.begin(), rcDates.end(), maturity);
        if (!(rcDate == rcDates.end() || *rcDate > prevRcDate)) {
            active[i] = false;
            continue;
        }
 
        if (rcDate != rcDates.end())
            prevRcDate = *rcDate;
 
        // Price the underlying helper instrument to get its fair rate.
        helperInst->setPricingEngine(engine);
 
        // Update the helper's market quote with the fair rate.
        quote->setValue(helperInst->fairRate());
 
        // For JY calibration to YoY swaps, the parameter's time depends on whether you are calibrating the real rate 
        // reversion or the real rate volatility (probably don't want to calibrate the inflation index vol to YoY 
        // swaps as it only shows up via the drift). If you are calibrating to real rate reversion, you want the time 
        // to the numerator index fixing date on the last YoY swaplet on the YoY leg. If you are calibrating to real 
        // rate volatility, you want the time to the denominator index fixing date on the last YoY swaplet on the YoY 
        // leg. We use numerator fixing date - 1 * Years here for this. You can see this from the parameter 
        // dependencies in the YoY swaplet formula in Section 13 of the book (i.e. T vs. S).
        // If t is not positive, we log a message and skip this helper.
        Time t = 0.0;
        QL_REQUIRE(!helperInst->yoyLeg().empty(), "InfJyBuilder: expected YoYSwap to have non-empty YoY leg.");
        auto finalYoYCoupon = QuantLib::ext::dynamic_pointer_cast<YoYInflationCoupon>(helperInst->yoyLeg().back());
        Date numFixingDate = finalYoYCoupon->fixingDate();
        if (forRealRateReversion) {
            t = inflationTime(numFixingDate, *yoyTs, yoyInflationIndex_->interpolated());
        } else {
            auto denFixingDate = numFixingDate - 1 * Years;
            t = inflationTime(denFixingDate, *yoyTs, yoyInflationIndex_->interpolated());
        }
 
        if (t < 0 || close_enough(t, 0.0)) {
            DLOG("The year on year swap with maturity tenor, " << yoySwap->tenor() << ", and date, " << maturity <<
                ", has a non-positive parameter time, " << t << ", so skipping this as a calibration instrument.");
            continue;
        }
 
        // Add the helper to the calibration helpers.
        helpers.push_back(helper);
 
        auto p = expiryTimes.insert(t);
        QL_REQUIRE(p.second, "InfJyBuilder: a YoY swap calibration instrument with the expiry " <<
            "time, " << t << ", was already added.");
 
        TLOG("InfJyBuilder: added year on year swap helper" <<
            ": index = " << data_->index() <<
            ", maturity = " << io::iso_date(maturity) <<
            ", obs lag = " << obsLag <<
            ", market rate = " << quote->value());
    }
 
    // Populate the expiry times array with the unique sorted expiry times.
    expiries = Array(expiryTimes.begin(), expiryTimes.end());
 
    DLOG("InfJyBuilder: finished building the YoY swap calibration basket.");
 
    return helpers;
}

Here is the call graph for this function:

Here is the caller graph for this function:

calibrationBasket()

const CalibrationBasket & calibrationBasket ( const std::string &  parameter ) const

private

Find calibration basket with parameter value equal to parameter.

Definition at line 625 of file infjybuilder.cpp.

                                                                                      {
 
    for (const auto& cb : data_->calibrationBaskets()) {
        if (cb.parameter() == parameter) {
            return cb;
        }
    }
 
    QL_FAIL("InfJyBuilder: unable to find calibration basket with parameter value equal to '" << parameter << "'.");
}

Here is the caller graph for this function:

createRealRateParam()

QuantLib::ext::shared_ptr< Lgm1fParametrization< ZeroInflationTermStructure > > createRealRateParam ( ) const

private

Create the real rate parameterisation.

Definition at line 636 of file infjybuilder.cpp.

                                                                                                                {
 
    DLOG("InfJyBuilder: start creating the real rate parameterisation.");
 
    // Initial parameter setup as provided by the data_.
    const ReversionParameter& rrReversion = data_->realRateReversion();
    const VolatilityParameter& rrVolatility = data_->realRateVolatility();
    Array rrVolatilityTimes(rrVolatility.times().begin(), rrVolatility.times().end());
    Array rrVolatilityValues(rrVolatility.values().begin(), rrVolatility.values().end());
    Array rrReversionTimes(rrReversion.times().begin(), rrReversion.times().end());
    Array rrReversionValues(rrReversion.values().begin(), rrReversion.values().end());
 
    // Perform checks and in the event of bootstrap calibration, may need to restructure the parameters.
    setupParams(rrReversion, rrReversionTimes, rrReversionValues, rrInstExpiries_, "RealRate reversion");
    setupParams(rrVolatility, rrVolatilityTimes, rrVolatilityValues, rrInstExpiries_, "RealRate volatility");
 
    // Create the JY parameterization.
    using RT = LgmData::ReversionType;
    using VT = LgmData::VolatilityType;
 
    // Real rate parameter constraints
    const auto& cc = data_->calibrationConfiguration();
    auto rrVolConstraint = cc.constraint("RealRateVolatility");
    auto rrRevConstraint = cc.constraint("RealRateReversion");
 
    // Create the real rate portion of the parameterization
    using QuantLib::ZeroInflationTermStructure;
    QuantLib::ext::shared_ptr<QuantExt::Lgm1fParametrization<ZeroInflationTermStructure>> realRateParam;
    if (rrReversion.reversionType() == RT::HullWhite && rrVolatility.volatilityType() == VT::HullWhite) {
        using QuantExt::Lgm1fPiecewiseConstantHullWhiteAdaptor;
        DLOG("InfJyBuilder: real rate parameterization is Lgm1fPiecewiseConstantHullWhiteAdaptor");
        realRateParam = QuantLib::ext::make_shared<Lgm1fPiecewiseConstantHullWhiteAdaptor<ZeroInflationTermStructure>>(
            zeroInflationIndex_->currency(), zeroInflationIndex_->zeroInflationTermStructure(), rrVolatilityTimes,
            rrVolatilityValues, rrReversionTimes, rrReversionValues, data_->index(), rrVolConstraint, rrRevConstraint);
    } else if (rrReversion.reversionType() == RT::HullWhite && rrVolatility.volatilityType() == VT::Hagan) {
        using QuantExt::Lgm1fPiecewiseConstantParametrization;
        DLOG("InfJyBuilder: real rate parameterization is Lgm1fPiecewiseConstantParametrization");
        realRateParam = QuantLib::ext::make_shared<Lgm1fPiecewiseConstantParametrization<ZeroInflationTermStructure>>(
            zeroInflationIndex_->currency(), zeroInflationIndex_->zeroInflationTermStructure(), rrVolatilityTimes,
            rrVolatilityValues, rrReversionTimes, rrReversionValues, data_->index(), rrVolConstraint, rrRevConstraint);
    } else if (rrReversion.reversionType() == RT::Hagan && rrVolatility.volatilityType() == VT::Hagan) {
        using QuantExt::Lgm1fPiecewiseLinearParametrization;
        DLOG("InfJyBuilder: real rate parameterization is Lgm1fPiecewiseLinearParametrization");
        realRateParam = QuantLib::ext::make_shared<Lgm1fPiecewiseLinearParametrization<ZeroInflationTermStructure>>(
            zeroInflationIndex_->currency(), zeroInflationIndex_->zeroInflationTermStructure(), rrVolatilityTimes,
            rrVolatilityValues, rrReversionTimes, rrReversionValues, data_->index(), rrVolConstraint, rrRevConstraint);
    } else {
        QL_FAIL("InfJyBuilder: reversion type Hagan and volatility type HullWhite not supported.");
    }
 
    Time horizon = data_->reversionTransformation().horizon();
    if (horizon >= 0.0) {
        DLOG("InfJyBuilder: apply shift horizon " << horizon << " to the JY real rate parameterisation for index " <<
            data_->index() << ".");
        realRateParam->shift() = horizon;
    } else {
        WLOG("InfJyBuilder: ignoring negative horizon, " << horizon <<
            ", passed to the JY real rate parameterisation for index " << data_->index() << ".");
    }
 
    Real scaling = data_->reversionTransformation().scaling();
    if (scaling > 0.0) {
        DLOG("InfJyBuilder: apply scaling " << scaling << " to the JY real rate parameterisation for index " <<
            data_->index() << ".");
        realRateParam->scaling() = scaling;
    } else {
        WLOG("Ignoring non-positive scaling, " << scaling <<
            ", passed to the JY real rate parameterisation for index " << data_->index() << ".");
    }
 
    DLOG("InfJyBuilder: finished creating the real rate parameterisation.");
 
    return realRateParam;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createIndexParam()

QuantLib::ext::shared_ptr< FxBsParametrization > createIndexParam ( ) const

private

Create the inflation index parameterisation.

Definition at line 711 of file infjybuilder.cpp.

                                                                                {
 
    DLOG("InfJyBuilder: start creating the index parameterisation.");
 
    // Initial parameter setup as provided by the data_.
    const VolatilityParameter& idxVolatility = data_->indexVolatility();
    Array idxVolatilityTimes(idxVolatility.times().begin(), idxVolatility.times().end());
    Array idxVolatilityValues(idxVolatility.values().begin(), idxVolatility.values().end());
 
    // Perform checks and in the event of bootstrap calibration, may need to restructure the parameters.
    setupParams(idxVolatility, idxVolatilityTimes, idxVolatilityValues, indexInstExpiries_, "Index volatility");
 
    // Create the index portion of the parameterization
    QuantLib::ext::shared_ptr<QuantExt::FxBsParametrization> indexParam;
 
    Handle<Quote> baseCpiQuote(QuantLib::ext::make_shared<SimpleQuote>(
        dontCalibrate_ ? 100
                       : zeroInflationIndex_->fixing(zeroInflationIndex_->zeroInflationTermStructure()->baseDate())));
 
    // Index volatility parameter constraints
    const auto& cc = data_->calibrationConfiguration();
    auto idxVolConstraint = cc.constraint("IndexVolatility");
 
    if (idxVolatility.type() == ParamType::Piecewise) {
        using QuantExt::FxBsPiecewiseConstantParametrization;
        DLOG("InfJyBuilder: index volatility parameterization is FxBsPiecewiseConstantParametrization");
        indexParam = QuantLib::ext::make_shared<FxBsPiecewiseConstantParametrization>(
            zeroInflationIndex_->currency(), baseCpiQuote, idxVolatilityTimes, idxVolatilityValues, idxVolConstraint);
    } else if (idxVolatility.type() == ParamType::Constant) {
        using QuantExt::FxBsConstantParametrization;
        DLOG("InfJyBuilder: index volatility parameterization is FxBsConstantParametrization");
        indexParam = QuantLib::ext::make_shared<FxBsConstantParametrization>(
            zeroInflationIndex_->currency(), baseCpiQuote, idxVolatilityValues[0]);
    } else {
        QL_FAIL("InfJyBuilder: index volatility parameterization needs to be Piecewise or Constant.");
    }
 
    DLOG("InfJyBuilder: finished creating the index parameterisation.");
 
    return indexParam;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupParams()

void setupParams ( const ModelParameter &  param, QuantLib::Array &  times, QuantLib::Array &  values, const QuantLib::Array &  expiries, const std::string &  paramName  ) const

private

Perform checks and possibly adjust the times and values array depending on calibration configuration.

Definition at line 753 of file infjybuilder.cpp.

                                                          {
 
    DLOG("InfJyBuilder: start setting up parameters for " << paramName);
 
    if (param.type() == ParamType::Constant) {
        QL_REQUIRE(param.times().size() == 0, "InfJyBuilder: parameter is constant so empty times expected");
        QL_REQUIRE(param.values().size() == 1, "InfJyBuilder: parameter is constant so initial value array " <<
            "should have 1 element.");
    } else if (param.type() == ParamType::Piecewise) {
 
        if (param.calibrate() && data_->calibrationType() == CalibrationType::Bootstrap) {
            QL_REQUIRE(!expiries.empty(), "InfJyBuilder: calibration instrument expiries are empty.");
            QL_REQUIRE(!values.empty(), "InfJyBuilder: expected at least one initial value.");
            DLOG("InfJyBuilder: overriding initial times " << times << " with option calibration instrument " <<
                "expiries " << expiries << ".");
            times = Array(expiries.begin(), expiries.end() - 1);
            values = Array(times.size() + 1, values[0]);
        } else {
            QL_REQUIRE(values.size() == times.size() + 1, "InfJyBuilder: size of values grid, " << values.size() <<
                ", should be 1 greater than the size of the times grid, " << times.size() << ".");
        }
 
    } else {
        QL_FAIL("Expected " << paramName << " parameter to be Constant or Piecewise.");
    }
 
    DLOG("InfJyBuilder: finished setting up parameters for " << paramName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

referenceCalibrationDates()

vector< Date > referenceCalibrationDates ( ) const

private

Create the reference calibration dates.

Definition at line 783 of file infjybuilder.cpp.

                                                           {
 
    TLOG("InfJyBuilder: start building reference date grid '" << referenceCalibrationGrid_ << "'.");
    
    vector<Date> res;
    if (!referenceCalibrationGrid_.empty())
        res = DateGrid(referenceCalibrationGrid_).dates();
 
    TLOG("InfJyBuilder: finished building reference date grid.");
 
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialiseMarket()

void initialiseMarket ( )

private

Attempt to initialise market data members that may be needed for building calibration instruments.

Definition at line 796 of file infjybuilder.cpp.

                                    {
 
    TLOG("InfJyBuilder: start initialising market data members.");
 
    // Try catches are not nice but Market does not have a method for checking if a structure exists so it is 
    // unfortunately necessary.
    try {
        cpiVolatility_ = market_->cpiInflationCapFloorVolatilitySurface(data_->index(), configuration_);
    } catch (...) {
        DLOG("InfJyBuilder: the market does not have a CPI cap floor volatility surface.");
    }
 
    try {
        yoyInflationIndex_ = *market_->yoyInflationIndex(data_->index(), configuration_);
        marketObserver_->registerWith(yoyInflationIndex_);
    } catch (...) {
        DLOG("InfJyBuilder: the market does not have a YoY inflation index.");
    }
 
    try {
        yoyVolatility_ = market_->yoyCapFloorVol(data_->index(), configuration_);
    } catch (...) {
        DLOG("InfJyBuilder: the market does not have a YoY cap floor volatility surface.");
    }
 
    TLOG("InfJyBuilder: finished initialising market data members.");
}

Here is the caller graph for this function:

pricesChanged()

bool pricesChanged ( bool  updateCache ) const

private

Returns true if the market value of any of the calibration helpers has changed. If updateCache is true, the cached prices are updated if they have changed.

Definition at line 824 of file infjybuilder.cpp.

                                                       {
    if(dontCalibrate_)
        return false;
 
    // Build the calibration instruments again before checking the market price below.
    // Don't need to do this if updateCache is true, because only called above after buildCalibrationBaskets().
    if (!updateCache)
        buildCalibrationBaskets();
 
    // Resize the cache to match the number of calibration instruments
    auto numInsts = realRateBasket_.size() + indexBasket_.size();
    if (priceCache_.size() != numInsts)
        priceCache_ = vector<Real>(numInsts, Null<Real>());
 
    // Check if any market prices have changed. Return true if they have and false if they have not.
    // If asked to update the cached prices, via updateCache being true, update the prices, if necessary.
    bool result = false;
    Size ctr = 0;
    for (const auto& ci : boost::range::join(realRateBasket_, indexBasket_)) {
        auto mp = marketPrice(ci);
        if (!close_enough(priceCache_[ctr], mp)) {
            if (updateCache)
                priceCache_[ctr] = mp;
            result = true;
        }
        ctr++;
    }
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

marketPrice()

Real marketPrice ( const QuantLib::ext::shared_ptr< QuantLib::CalibrationHelper > &  helper ) const

private

Return the market value of the given calibration helper.

Definition at line 855 of file infjybuilder.cpp.

                                                                                           {
 
    if (auto h = QuantLib::ext::dynamic_pointer_cast<CpiCapFloorHelper>(helper)) {
        return h->marketValue();
    }
 
    if (auto h = QuantLib::ext::dynamic_pointer_cast<YoYCapFloorHelper>(helper)) {
        return h->marketValue();
    }
 
    if (QuantLib::ext::shared_ptr<YoYSwapHelper> h = QuantLib::ext::dynamic_pointer_cast<YoYSwapHelper>(helper)) {
        return h->marketRate();
    }
 
    QL_FAIL("InfJyBuilder: unrecognised calibration instrument for JY calibration.");
}

Here is the caller graph for this function:

Member Data Documentation

market_

QuantLib::ext::shared_ptr<Market> market_

private

Definition at line 73 of file infjybuilder.hpp.

configuration_

std::string configuration_

private

Definition at line 74 of file infjybuilder.hpp.

data_

QuantLib::ext::shared_ptr<InfJyData> data_

private

Definition at line 75 of file infjybuilder.hpp.

referenceCalibrationGrid_

std::string referenceCalibrationGrid_

private

Definition at line 76 of file infjybuilder.hpp.

dontCalibrate_

bool dontCalibrate_

private

Definition at line 77 of file infjybuilder.hpp.

parameterization_

QuantLib::ext::shared_ptr<QuantExt::InfJyParameterization> parameterization_

private

Definition at line 79 of file infjybuilder.hpp.

marketObserver_

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

private

Definition at line 80 of file infjybuilder.hpp.

rateCurve_

Handle<YieldTermStructure> rateCurve_

private

Definition at line 83 of file infjybuilder.hpp.

zeroInflationIndex_

QuantLib::ext::shared_ptr<QuantLib::ZeroInflationIndex> zeroInflationIndex_

private

Definition at line 86 of file infjybuilder.hpp.

cpiVolatility_

QuantLib::Handle<QuantLib::CPIVolatilitySurface> cpiVolatility_

private

Definition at line 89 of file infjybuilder.hpp.

yoyInflationIndex_

QuantLib::ext::shared_ptr<QuantLib::YoYInflationIndex> yoyInflationIndex_

private

Definition at line 90 of file infjybuilder.hpp.

yoyVolatility_

QuantLib::Handle<QuantLib::YoYOptionletVolatilitySurface> yoyVolatility_

private

Definition at line 91 of file infjybuilder.hpp.

forceCalibration_

bool forceCalibration_ = false

private

Definition at line 94 of file infjybuilder.hpp.

realRateBasket_

Helpers realRateBasket_

mutableprivate

Calibration instruments to use for calibrating the real rate portion of the JY model. The basket is empty if we are not calibrating the real rate portion of the JY model. Depending on the calibration configuration, either the real rate reversion parameter or the real rate volatility parameter will be adjusted in order to match these instruments.

Definition at line 101 of file infjybuilder.hpp.

rrInstActive_

std::vector<bool> rrInstActive_

mutableprivate

Definition at line 102 of file infjybuilder.hpp.

rrInstExpiries_

QuantLib::Array rrInstExpiries_

mutableprivate

Definition at line 103 of file infjybuilder.hpp.

indexBasket_

Helpers indexBasket_

mutableprivate

Calibration instruments to use for calibrating the inflation index portion of the JY model. The basket is empty if we are not calibrating the inflation index portion of the JY model.

Definition at line 108 of file infjybuilder.hpp.

indexInstActive_

std::vector<bool> indexInstActive_

mutableprivate

Definition at line 109 of file infjybuilder.hpp.

indexInstExpiries_

QuantLib::Array indexInstExpiries_

mutableprivate

Definition at line 110 of file infjybuilder.hpp.

priceCache_

std::vector<QuantLib::Real> priceCache_

mutableprivate

Cache the prices of all of the active calibration helper instruments.

Definition at line 113 of file infjybuilder.hpp.