LocalVolModelBuilder Class Reference

#include <ored/model/localvolmodelbuilder.hpp>

Inheritance diagram for LocalVolModelBuilder:

Collaboration diagram for LocalVolModelBuilder:

Public Types
enum class	Type { Dupire , DupireFloored , AndreasenHuge }

Public Member Functions
	LocalVolModelBuilder (const std::vector< Handle< YieldTermStructure > > &curves, const std::vector< ext::shared_ptr< GeneralizedBlackScholesProcess > > &processes, const std::set< Date > &simulationDates={}, const std::set< Date > &addDates={}, const Size timeStepsPerYear=1, const Type lvType=Type::Dupire, const std::vector< Real > &calibrationMoneyness={ -2.0, -1.0, 0.0, 1.0, 2.0 }, const bool dontCalibrate=false)
	LocalVolModelBuilder (const Handle< YieldTermStructure > &curve, const ext::shared_ptr< GeneralizedBlackScholesProcess > &process, const std::set< Date > &simulationDates={}, const std::set< Date > &addDates={}, const Size timeStepsPerYear=1, const Type lvType=Type::Dupire, const std::vector< Real > &calibrationMoneyness={ -2.0, -1.0, 0.0, 1.0, 2.0 }, const bool dontCalibrate=false)
std::vector< ext::shared_ptr< GeneralizedBlackScholesProcess > >	getCalibratedProcesses () const override
Public Member Functions inherited from BlackScholesModelBuilderBase
	BlackScholesModelBuilderBase (const std::vector< Handle< YieldTermStructure > > &curves, const std::vector< QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > > &processes, const std::set< Date > &simulationDates, const std::set< Date > &addDates, const Size timeStepsPerYear)
	BlackScholesModelBuilderBase (const Handle< YieldTermStructure > &curve, const QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > &process, const std::set< Date > &simulationDates, const std::set< Date > &addDates, const Size timeStepsPerYear)
Handle< BlackScholesModelWrapper >	model () const
void	forceRecalculate () override
bool	requiresRecalibration () const override
Public Member Functions inherited from ModelBuilder
void	recalibrate () const
virtual void	forceRecalculate ()
virtual bool	requiresRecalibration () const=0

Protected Member Functions
std::vector< std::vector< Real > >	getCurveTimes () const override
std::vector< std::vector< std::pair< Real, Real > > >	getVolTimesStrikes () const override
Protected Member Functions inherited from BlackScholesModelBuilderBase
	BlackScholesModelBuilderBase (const Handle< YieldTermStructure > &curve, const QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > &process)
virtual void	setupDatesAndTimes () const
void	performCalculations () const override
bool	calibrationPointsChanged (const bool updateCache) const

Private Attributes
const Type	lvType_
const std::vector< Real >	calibrationMoneyness_
const bool	dontCalibrate_

Additional Inherited Members
Protected Attributes inherited from BlackScholesModelBuilderBase
const std::vector< Handle< YieldTermStructure > >	curves_
const std::vector< QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > >	processes_
const std::set< Date >	simulationDates_
const std::set< Date >	addDates_
const Size	timeStepsPerYear_
std::set< Date >	effectiveSimulationDates_
TimeGrid	discretisationTimeGrid_
RelinkableHandle< BlackScholesModelWrapper >	model_
bool	forceCalibration_ = false
QuantLib::ext::shared_ptr< MarketObserver >	marketObserver_
std::vector< Handle< BlackVolTermStructure > >	vols_
std::vector< Handle< YieldTermStructure > >	allCurves_
CalibrationPointCache	cache_

Detailed Description

Definition at line 33 of file localvolmodelbuilder.hpp.

Member Enumeration Documentation

Type

enum class Type

strong

Enumerator
Dupire
DupireFloored
AndreasenHuge

Definition at line 35 of file localvolmodelbuilder.hpp.

{ Dupire, DupireFloored, AndreasenHuge };

Constructor & Destructor Documentation

LocalVolModelBuilder() [1/2]

LocalVolModelBuilder	(	const std::vector< Handle< YieldTermStructure > > &	curves,
		const std::vector< ext::shared_ptr< GeneralizedBlackScholesProcess > > &	processes,
		const std::set< Date > &	simulationDates = {},
		const std::set< Date > &	addDates = {},
		const Size	timeStepsPerYear = 1,
		const Type	lvType = Type::Dupire,
		const std::vector< Real > &	calibrationMoneyness = { -2.0, -1.0, 0.0, 1.0, 2.0 },
		const bool	dontCalibrate = false
	)

Definition at line 40 of file localvolmodelbuilder.cpp.

    : BlackScholesModelBuilderBase(curves, processes, simulationDates, addDates, timeStepsPerYear), lvType_(lvType),
      calibrationMoneyness_(calibrationMoneyness), dontCalibrate_(dontCalibrate) {
    // we have to observe the whole vol surface for the Dupire implementation unfortunately; we can specify the time
    // steps that are relevant, but not a set of discrete strikes
    if (lvType == Type::Dupire) {
        for (auto const& p : processes_) {
            marketObserver_->registerWith(p->blackVolatility());
        }
    }
}

LocalVolModelBuilder() [2/2]

LocalVolModelBuilder	(	const Handle< YieldTermStructure > &	curve,
		const ext::shared_ptr< GeneralizedBlackScholesProcess > &	process,
		const std::set< Date > &	simulationDates = {},
		const std::set< Date > &	addDates = {},
		const Size	timeStepsPerYear = 1,
		const Type	lvType = Type::Dupire,
		const std::vector< Real > &	calibrationMoneyness = { -2.0, -1.0, 0.0, 1.0, 2.0 },
		const bool	dontCalibrate = false
	)

Definition at line 44 of file localvolmodelbuilder.hpp.

                                                               {},
                         const std::set<Date>& addDates = {},
                         const Size timeStepsPerYear = 1,
                         const Type lvType = Type::Dupire,
                         const std::vector<Real>& calibrationMoneyness = { -2.0, -1.0, 0.0, 1.0, 2.0 },
                         const bool dontCalibrate = false)
        : LocalVolModelBuilder(std::vector<Handle<YieldTermStructure>>{curve},
                               std::vector<ext::shared_ptr<GeneralizedBlackScholesProcess>>{process}, simulationDates,
                               addDates, timeStepsPerYear, lvType, calibrationMoneyness, dontCalibrate) {}

Member Function Documentation

getCalibratedProcesses()

std::vector< QuantLib::ext::shared_ptr< GeneralizedBlackScholesProcess > > getCalibratedProcesses ( ) const

overridevirtual

Implements BlackScholesModelBuilderBase.

Definition at line 56 of file localvolmodelbuilder.cpp.

                                                                                                                    {
 
    QL_REQUIRE(lvType_ != Type::AndreasenHuge || !calibrationMoneyness_.empty(), "no calibration moneyness provided");
 
    calculate();
    
    std::vector<QuantLib::ext::shared_ptr<GeneralizedBlackScholesProcess>> processes;
 
    for (Size l = 0; l < processes_.size(); ++l) {
 
        Handle<LocalVolTermStructure> localVol;
        if (dontCalibrate_) {
            localVol = Handle<LocalVolTermStructure>(
                QuantLib::ext::make_shared<LocalConstantVol>(0, NullCalendar(), 0.10, ActualActual(ActualActual::ISDA)));
        } else if (lvType_ == Type::AndreasenHuge) {
            // for checking arbitrage free input prices, just for logging purposes at this point
            // notice that we need a uniform strike grid here, so this is not the same as the one below
            // we choose the strike grid to be the one for the last calibration point
            std::vector<Real> checkMaturities, checkMoneynesses, atmForwards;
            std::vector<std::vector<Real>> callPrices;
 
            // set up Andreasen Huge Volatility interpolation for each underyling
            // we choose the calibration set to be OTM options on the effective future simulation dates
            // with strikes given in terms of moneyness K / atmForward
            AndreasenHugeVolatilityInterpl::CalibrationSet calSet;
            for (auto const& d : effectiveSimulationDates_) {
                if (d <= curves_.front()->referenceDate())
                    continue;
                Real t = processes_.front()->riskFreeRate()->timeFromReference(d);
                checkMaturities.push_back(t);
                Real atmLevel =
                    atmForward(processes_[l]->x0(), processes_[l]->riskFreeRate(), processes_[l]->dividendYield(), t);
                Real atmMarketVol = std::max(1e-4, processes_[l]->blackVolatility()->blackVol(t, atmLevel));
                callPrices.push_back(std::vector<Real>());
                atmForwards.push_back(atmLevel);
                for (Size i = 0; i < calibrationMoneyness_.size(); ++i) {
                    Real strike = atmLevel * std::exp(calibrationMoneyness_[i] * atmMarketVol * std::sqrt(t));
                    Real marketVol = processes_[l]->blackVolatility()->blackVol(t, strike);
                    // skip option with effective moneyness < 0.0001 or > 0.9999 (TODO, hardcoded limits here?)
                    if (std::fabs(calibrationMoneyness_[i]) > 3.72)
                        continue;
                    auto option =
                        QuantLib::ext::make_shared<VanillaOption>(QuantLib::ext::make_shared<PlainVanillaPayoff>(Option::Call, strike),
                                                          QuantLib::ext::make_shared<EuropeanExercise>(d));
                    calSet.push_back(std::make_pair(option, QuantLib::ext::make_shared<SimpleQuote>(marketVol)));
                    option->setPricingEngine(QuantLib::ext::make_shared<AnalyticEuropeanEngine>(processes_[l]));
                    callPrices.back().push_back(option->NPV());
                    if (d == *effectiveSimulationDates_.rbegin()) {
                        checkMoneynesses.push_back(strike / atmLevel);
                    }
                }
            }
 
            // arbitrage check
            QuantExt::CarrMadanSurface cmCheck(checkMaturities, checkMoneynesses, processes_[l]->x0(), atmForwards,
                                               callPrices);
            if (!cmCheck.arbitrageFree()) {
                WLOG("Andreasen-Huge local vol calibration for process #" << l
                                                                          << ":, input vol is not arbitrage free:");
                DLOG("time,moneyness,callSpread,butterfly,calendar");
                for (Size i = 0; i < checkMaturities.size(); ++i)
                    for (Size j = 0; j < checkMoneynesses.size(); ++j)
                        DLOG(checkMaturities[i] << "," << checkMoneynesses[i] << "," << std::boolalpha
                                                << cmCheck.callSpreadArbitrage()[i][j] << ","
                                                << cmCheck.butterflyArbitrage()[i][j] << ","
                                                << cmCheck.calendarArbitrage()[i][j]);
            }
 
            // TODO using some hardcoded values here, expose to configuration?
            auto ah = QuantLib::ext::make_shared<AndreasenHugeVolatilityInterpl>(
                calSet, processes_[l]->stateVariable(), processes_[l]->riskFreeRate(), processes_[l]->dividendYield(),
                AndreasenHugeVolatilityInterpl::CubicSpline, AndreasenHugeVolatilityInterpl::Call, 500, Null<Real>(),
                Null<Real>());
            localVol = Handle<LocalVolTermStructure>(QuantLib::ext::make_shared<AndreasenHugeLocalVolAdapter>(ah));
            //localVol->enableExtrapolation();
            DLOG("Andreasen-Huge local vol calibration for process #"
                 << l
                 << ": "
                    "calibration error min="
                 << std::scientific << std::setprecision(6) << QuantLib::ext::get<0>(ah->calibrationError()) << " max="
                 << QuantLib::ext::get<1>(ah->calibrationError()) << " avg=" << QuantLib::ext::get<2>(ah->calibrationError()));
        } else if (lvType_ == Type::Dupire) {
            localVol = Handle<LocalVolTermStructure>(
                QuantLib::ext::make_shared<LocalVolSurface>(processes_[l]->blackVolatility(), processes_[l]->riskFreeRate(),
                                                    processes_[l]->dividendYield(), processes_[l]->stateVariable()));
        } else if (lvType_ == Type::DupireFloored) {
            localVol = Handle<LocalVolTermStructure>(
                QuantLib::ext::make_shared<NoExceptLocalVolSurface>(processes_[l]->blackVolatility(), processes_[l]->riskFreeRate(),
                                                            processes_[l]->dividendYield(), processes_[l]->stateVariable(),
                                                            0.0));
        } else {
            QL_FAIL("unexpected local vol type");
        }
 
        processes.push_back(QuantLib::ext::make_shared<GeneralizedBlackScholesProcess>(
            processes_[l]->stateVariable(), processes_[l]->dividendYield(), processes_[l]->riskFreeRate(),
            processes_[l]->blackVolatility(), localVol));
    }
 
    return processes;
}

Here is the call graph for this function:

getCurveTimes()

std::vector< std::vector< Real > > getCurveTimes ( ) const

overrideprotectedvirtual

Implements BlackScholesModelBuilderBase.

Definition at line 158 of file localvolmodelbuilder.cpp.

                                                                     {
    std::vector<Real> timesExt(discretisationTimeGrid_.begin() + 1, discretisationTimeGrid_.end());
    for (auto const& d : addDates_) {
        if (d > curves_.front()->referenceDate()) {
            timesExt.push_back(curves_.front()->timeFromReference(d));
        }
    }
    std::sort(timesExt.begin(), timesExt.end());
    auto it = std::unique(timesExt.begin(), timesExt.end(),
                          [](const Real x, const Real y) { return QuantLib::close_enough(x, y); });
    timesExt.resize(std::distance(timesExt.begin(), it));
    return std::vector<std::vector<Real>>(allCurves_.size(), timesExt);
}

getVolTimesStrikes()

std::vector< std::vector< std::pair< Real, Real > > > getVolTimesStrikes ( ) const

overrideprotectedvirtual

Implements BlackScholesModelBuilderBase.

Definition at line 172 of file localvolmodelbuilder.cpp.

                                                                                         {
    std::vector<std::vector<std::pair<Real, Real>>> volTimesStrikes;
    // for the Dupire implementation we observe the whole vol surface anyhow (see ctor above)
    if (lvType_ == Type::Dupire)
        return volTimesStrikes;
    std::vector<Real> times;
    if (lvType_ == Type::AndreasenHuge) {
        for (auto const& d : effectiveSimulationDates_) {
            if (d > curves_.front()->referenceDate())
                times.push_back(processes_.front()->riskFreeRate()->timeFromReference(d));
        }
    } else {
        times = std::vector<Real>(discretisationTimeGrid_.begin() + 1, discretisationTimeGrid_.end());
    }
    for (auto const& p : processes_) {
        volTimesStrikes.push_back(std::vector<std::pair<Real, Real>>());
        for (auto const t : times) {
            Real atmLevel = atmForward(p->x0(), p->riskFreeRate(), p->dividendYield(), t);
            Real atmMarketVol = std::max(1e-4, p->blackVolatility()->blackVol(t, atmLevel));
            for (auto const m : calibrationMoneyness_) {
                Real strike = atmLevel * std::exp(m * atmMarketVol * std::sqrt(t));
                volTimesStrikes.back().push_back(std::make_pair(t, strike));
            }
        }
    }
    return volTimesStrikes;
}

Here is the call graph for this function:

Member Data Documentation

lvType_

const Type lvType_

private

Definition at line 63 of file localvolmodelbuilder.hpp.

calibrationMoneyness_

const std::vector<Real> calibrationMoneyness_

private

Definition at line 64 of file localvolmodelbuilder.hpp.

dontCalibrate_

const bool dontCalibrate_

private

Definition at line 65 of file localvolmodelbuilder.hpp.