FxBsBuilder Class Reference

Builder for a Lognormal FX model component. More...

#include <ored/model/fxbsbuilder.hpp>

Inheritance diagram for FxBsBuilder:

Collaboration diagram for FxBsBuilder:

Public Member Functions
	FxBsBuilder (const QuantLib::ext::shared_ptr< ore::data::Market > &market, const QuantLib::ext::shared_ptr< FxBsData > &data, const std::string &configuration=Market::defaultConfiguration, const std::string &referenceCalibrationGrid="")
	Constructor. More...
Real	error () const
	Return calibration error. More...
Inspectors
std::string	foreignCurrency ()
QuantLib::ext::shared_ptr< QuantExt::FxBsParametrization >	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< FxBsData >	data_
const std::string	referenceCalibrationGrid_
Real	error_
QuantLib::ext::shared_ptr< QuantExt::FxBsParametrization >	parametrization_
std::vector< bool >	optionActive_
std::vector< QuantLib::ext::shared_ptr< BlackCalibrationHelper > >	optionBasket_
Array	optionExpiries_
Handle< Quote >	fxSpot_
Handle< YieldTermStructure >	ytsDom_
Handle< YieldTermStructure >	ytsFor_
Handle< BlackVolTermStructure >	fxVol_
std::vector< QuantLib::Real >	fxVolCache_
bool	forceCalibration_ = false
QuantLib::ext::shared_ptr< QuantExt::MarketObserver >	marketObserver_
void	forceRecalculate () override
bool	requiresRecalibration () const override
void	setCalibrationDone () const
void	performCalculations () const override
Real	optionStrike (const Size j) const
Date	optionExpiry (const Size j) const
void	buildOptionBasket () const
bool	volSurfaceChanged (const bool updateCache) const

Detailed Description

Builder for a Lognormal FX model component.

This class is a utility to turn an FX model component's description into an FX model parametrization which can be used to ultimately instantiate a CrossAssetModel.

Definition at line 48 of file fxbsbuilder.hpp.

Constructor & Destructor Documentation

FxBsBuilder()

FxBsBuilder	(	const QuantLib::ext::shared_ptr< ore::data::Market > &	market,
		const QuantLib::ext::shared_ptr< FxBsData > &	data,
		const std::string &	configuration = Market::defaultConfiguration,
		const std::string &	referenceCalibrationGrid = ""
	)

Constructor.

Parameters

market	Market object
data	FX model parameters/description
configuration	Market configuration to use
referenceCalibrationGrid	the reference calibration grid

Definition at line 41 of file fxbsbuilder.cpp.

    : market_(market), configuration_(configuration), data_(data), referenceCalibrationGrid_(referenceCalibrationGrid) {
 
    optionActive_ = std::vector<bool>(data_->optionExpiries().size(), false);
    marketObserver_ = QuantLib::ext::make_shared<MarketObserver>();
    QuantLib::Currency ccy = ore::data::parseCurrency(data->foreignCcy());
    QuantLib::Currency domesticCcy = ore::data::parseCurrency(data->domesticCcy());
    std::string ccyPair = ccy.code() + domesticCcy.code();
 
    LOG("Start building FxBs model for " << ccyPair);
 
    // get market data
    fxSpot_ = market_->fxSpot(ccyPair, configuration_);
    ytsDom_ = market_->discountCurve(domesticCcy.code(), configuration_);
    ytsFor_ = market_->discountCurve(ccy.code(), configuration_);
 
    // register with market observables except vols
    marketObserver_->addObservable(fxSpot_);
    marketObserver_->addObservable(market_->discountCurve(domesticCcy.code()));
    marketObserver_->addObservable(market_->discountCurve(ccy.code()));
 
    // register the builder with the market observer
    registerWith(marketObserver_);
 
    // notify observers of all market data changes, not only when not calculated
    alwaysForwardNotifications();
 
    // build option basket and derive parametrization from it
    if (data->calibrateSigma()) {
        fxVol_ = market_->fxVol(ccyPair, configuration_);
        registerWith(fxVol_);
        buildOptionBasket();
    }
 
    Array sigmaTimes, sigma;
    if (data->sigmaParamType() == ParamType::Constant) {
        QL_REQUIRE(data->sigmaTimes().size() == 0, "empty sigma tme grid expected");
        QL_REQUIRE(data->sigmaValues().size() == 1, "initial sigma grid size 1 expected");
        sigmaTimes = Array(0);
        sigma = Array(data_->sigmaValues().begin(), data_->sigmaValues().end());
    } else {
        if (data->calibrateSigma() && data->calibrationType() == CalibrationType::Bootstrap) { // override
            QL_REQUIRE(optionExpiries_.size() > 0, "optionExpiries is empty");
            sigmaTimes = Array(optionExpiries_.begin(), optionExpiries_.end() - 1);
            sigma = Array(sigmaTimes.size() + 1, data->sigmaValues()[0]);
        } else {
            // use input time grid and input alpha array otherwise
            sigmaTimes = Array(data_->sigmaTimes().begin(), data_->sigmaTimes().end());
            sigma = Array(data_->sigmaValues().begin(), data_->sigmaValues().end());
            QL_REQUIRE(sigma.size() == sigmaTimes.size() + 1, "sigma grids do not match");
        }
    }
 
    DLOG("sigmaTimes before calibration: " << sigmaTimes);
    DLOG("sigma before calibration: " << sigma);
 
    if (data->sigmaParamType() == ParamType::Piecewise)
        parametrization_ =
            QuantLib::ext::make_shared<QuantExt::FxBsPiecewiseConstantParametrization>(ccy, fxSpot_, sigmaTimes, sigma);
    else if (data->sigmaParamType() == ParamType::Constant)
        parametrization_ = QuantLib::ext::make_shared<QuantExt::FxBsConstantParametrization>(ccy, fxSpot_, sigma[0]);
    else
        QL_FAIL("interpolation type not supported for FX");
}

Here is the call graph for this function:

Member Function Documentation

error()

Real error

(

)

const

Return calibration error.

Definition at line 107 of file fxbsbuilder.cpp.

                              {
    calculate();
    return error_;
}

foreignCurrency()

std::string foreignCurrency

(

)

Definition at line 65 of file fxbsbuilder.hpp.

{ return data_->foreignCcy(); }

parametrization()

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

(

)

const

Definition at line 112 of file fxbsbuilder.cpp.

                                                                                      {
    calculate();
    return parametrization_;
}

optionBasket()

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

(

)

const

Definition at line 116 of file fxbsbuilder.cpp.

                                                                                         {
    calculate();
    return optionBasket_;
}

forceRecalculate()

void forceRecalculate ( )

overridevirtual

Reimplemented from ModelBuilder.

Definition at line 237 of file fxbsbuilder.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 121 of file fxbsbuilder.cpp.

                                              {
    return data_->calibrateSigma() &&
           (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 133 of file fxbsbuilder.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 126 of file fxbsbuilder.cpp.

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

Here is the call graph for this function:

optionStrike()

Real optionStrike ( const Size  j ) const

private

Definition at line 140 of file fxbsbuilder.cpp.

                                                 {
    Date expiryDate = optionExpiry(j);
    ore::data::Strike strike = ore::data::parseStrike(data_->optionStrikes()[j]);
    Real strikeValue;
    BlackDeltaCalculator bdc(Option::Type::Call, DeltaVolQuote::DeltaType::Spot, fxSpot_->value(),
                             ytsDom_->discount(expiryDate), ytsFor_->discount(expiryDate),
                             fxVol_->blackVol(expiryDate, Null<Real>()) * sqrt(fxVol_->timeFromReference(expiryDate)));
 
    // TODO: Extend strike type coverage
    if (strike.type == ore::data::Strike::Type::ATMF)
        strikeValue = bdc.atmStrike(DeltaVolQuote::AtmFwd);
    else if (strike.type == ore::data::Strike::Type::Absolute)
        strikeValue = strike.value;
    else
        QL_FAIL("strike type ATMF or Absolute expected");
    Handle<Quote> quote(QuantLib::ext::make_shared<SimpleQuote>(fxVol_->blackVol(expiryDate, strikeValue)));
    return strikeValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

optionExpiry()

Date optionExpiry ( const Size  j ) const

private

Definition at line 159 of file fxbsbuilder.cpp.

                                                 {
    Date today = Settings::instance().evaluationDate();
    std::string expiryString = data_->optionExpiries()[j];
    bool expiryDateBased;
    Period expiryPb;
    Date expiryDb;
    parseDateOrPeriod(expiryString, expiryDb, expiryPb, expiryDateBased);
    Date expiryDate = expiryDateBased ? expiryDb : today + expiryPb;
    return expiryDate;
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildOptionBasket()

void buildOptionBasket ( ) const

private

Definition at line 192 of file fxbsbuilder.cpp.

                                          {
    QL_REQUIRE(data_->optionExpiries().size() == data_->optionStrikes().size(), "fx option vector size mismatch");
 
    DLOG("build reference date grid '" << referenceCalibrationGrid_ << "'");
    Date lastRefCalDate = Date::minDate();
    std::vector<Date> referenceCalibrationDates;
    if (!referenceCalibrationGrid_.empty())
        referenceCalibrationDates = DateGrid(referenceCalibrationGrid_).dates();
 
    optionBasket_.clear();
    std::vector<Time> expiryTimes;
    for (Size j = 0; j < data_->optionExpiries().size(); j++) {
        Date expiryDate = optionExpiry(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) {
            optionActive_[j] = true;
            Real strikeValue = optionStrike(j);
            Handle<Quote> quote(QuantLib::ext::make_shared<SimpleQuote>(fxVol_->blackVol(expiryDate, strikeValue)));
            QuantLib::ext::shared_ptr<QuantExt::FxEqOptionHelper> helper = QuantLib::ext::make_shared<QuantExt::FxEqOptionHelper>(
                expiryDate, strikeValue, fxSpot_, quote, ytsDom_, ytsFor_);
            optionBasket_.push_back(helper);
            helper->performCalculations();
            expiryTimes.push_back(ytsDom_->timeFromReference(helper->option()->exercise()->date(0)));
            DLOG("Added FxEqOptionHelper " << (data_->foreignCcy() + data_->domesticCcy()) << " "
                                           << QuantLib::io::iso_date(expiryDate) << " " << helper->strike() << " "
                                           << quote->value());
            if (refCalDate != referenceCalibrationDates.end())
                lastRefCalDate = *refCalDate;
        } else {
            optionActive_[j] = false;
        }
    }
 
    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 170 of file fxbsbuilder.cpp.

                                                                {
    bool hasUpdated = false;
 
    // if cache doesn't exist resize vector
    if (fxVolCache_.size() != optionBasket_.size())
        fxVolCache_ = vector<Real>(optionBasket_.size(), Null<Real>());
 
    Size optionCounter = 0;
    for (Size j = 0; j < data_->optionExpiries().size(); j++) {
        if (!optionActive_[j])
            continue;
        Real vol = fxVol_->blackVol(optionExpiry(j), optionStrike(j));
        if (!close_enough(fxVolCache_[optionCounter], vol)) {
            if (updateCache)
                fxVolCache_[optionCounter] = vol;
            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 87 of file fxbsbuilder.hpp.

configuration_

const std::string configuration_

private

Definition at line 88 of file fxbsbuilder.hpp.

data_

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

private

Definition at line 89 of file fxbsbuilder.hpp.

referenceCalibrationGrid_

const std::string referenceCalibrationGrid_

private

Definition at line 90 of file fxbsbuilder.hpp.

error_

Real error_

mutableprivate

Definition at line 93 of file fxbsbuilder.hpp.

parametrization_

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

private

Definition at line 94 of file fxbsbuilder.hpp.

optionActive_

std::vector<bool> optionActive_

mutableprivate

Definition at line 97 of file fxbsbuilder.hpp.

optionBasket_

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

mutableprivate

Definition at line 98 of file fxbsbuilder.hpp.

optionExpiries_

Array optionExpiries_

mutableprivate

Definition at line 99 of file fxbsbuilder.hpp.

fxSpot_

Handle<Quote> fxSpot_

private

Definition at line 102 of file fxbsbuilder.hpp.

ytsDom_

Handle<YieldTermStructure> ytsDom_

private

Definition at line 103 of file fxbsbuilder.hpp.

ytsFor_

Handle<YieldTermStructure> ytsFor_

private

Definition at line 103 of file fxbsbuilder.hpp.

fxVol_

Handle<BlackVolTermStructure> fxVol_

private

Definition at line 104 of file fxbsbuilder.hpp.

fxVolCache_

std::vector<QuantLib::Real> fxVolCache_

mutableprivate

Definition at line 107 of file fxbsbuilder.hpp.

forceCalibration_

bool forceCalibration_ = false

private

Definition at line 110 of file fxbsbuilder.hpp.

marketObserver_

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

private

Definition at line 113 of file fxbsbuilder.hpp.