SwaptionVolCube2 Class Reference

#include <qle/termstructures/swaptionvolcube2.hpp>

Inheritance diagram for SwaptionVolCube2:

Collaboration diagram for SwaptionVolCube2:

Public Member Functions
	SwaptionVolCube2 (const Handle< SwaptionVolatilityStructure > &atmVolStructure, const std::vector< Period > &optionTenors, const std::vector< Period > &swapTenors, const std::vector< Spread > &strikeSpreads, const std::vector< std::vector< Handle< Quote > > > &volSpreads, const QuantLib::ext::shared_ptr< SwapIndex > &swapIndexBase, const QuantLib::ext::shared_ptr< SwapIndex > &shortSwapIndexBase, bool vegaWeightedSmileFit, bool flatExtrapolation, bool volsAreSpreads=true)
LazyObject interface
void	performCalculations () const override

SwaptionVolatilityCube inspectors
const bool	flatExtrapolation_
const bool	volsAreSpreads_
std::vector< Interpolation2D >	volSpreadsInterpolator_
std::vector< Matrix >	volSpreadsMatrix_
const Matrix &	volSpreads (Size i) const
QuantLib::ext::shared_ptr< SmileSection >	smileSectionImpl (const Date &optionDate, const Period &swapTenor) const override
QuantLib::ext::shared_ptr< SmileSection >	smileSectionImpl (Time optionTime, Time swapLength) const override

Detailed Description

Definition at line 50 of file swaptionvolcube2.hpp.

Constructor & Destructor Documentation

SwaptionVolCube2()

SwaptionVolCube2	(	const Handle< SwaptionVolatilityStructure > &	atmVolStructure,
		const std::vector< Period > &	optionTenors,
		const std::vector< Period > &	swapTenors,
		const std::vector< Spread > &	strikeSpreads,
		const std::vector< std::vector< Handle< Quote > > > &	volSpreads,
		const QuantLib::ext::shared_ptr< SwapIndex > &	swapIndexBase,
		const QuantLib::ext::shared_ptr< SwapIndex > &	shortSwapIndexBase,
		bool	vegaWeightedSmileFit,
		bool	flatExtrapolation,
		bool	volsAreSpreads = true
	)

The swaption vol cube is made up of ordered swaption vol surface layers, each layer referring to a swap index of a given length (in years), all indexes belonging to the same family. In order to identify the family (and its market conventions) an index of whatever length from that family must be passed in as swapIndexBase.

Often for short swap length the swap index family is different, e.g. the EUR case: swap vs 6M Euribor is used for length>1Y, while swap vs 3M Euribor is used for the 1Y length. The shortSwapIndexBase is used to identify this second family.

If flatExtrapolation is true the implied volatility is extrapolated flat in strike direction.

in case volsAreSpreads is false the given volSpreads are interpreted as absolute vols, in this case the volSpreads inspectors also return absolute vols

Definition at line 50 of file swaptionvolcube2.cpp.

    : SwaptionVolatilityCube(atmVolStructure, optionTenors, swapTenors, strikeSpreads, volSpreads, swapIndexBase,
                             shortSwapIndexBase, vegaWeightedSmileFit),
      flatExtrapolation_(flatExtrapolation), volsAreSpreads_(volsAreSpreads), volSpreadsInterpolator_(nStrikes_),
      volSpreadsMatrix_(nStrikes_, Matrix(optionTenors.size(), swapTenors.size(), 0.0)) {
    QL_REQUIRE(std::find(strikeSpreads_.begin(), strikeSpreads_.end(), 0.0) != strikeSpreads_.end(),
               "SwaptionVolCube2: strikeSpreads must contain 0.0 for atm vols");
}

Member Function Documentation

performCalculations()

void performCalculations ( ) const

override

Definition at line 65 of file swaptionvolcube2.cpp.

                                                 {
 
    SwaptionVolatilityCube::performCalculations();
    //! set volSpreadsMatrix_ by volSpreads_ quotes
    for (Size i = 0; i < nStrikes_; i++)
        for (Size j = 0; j < nOptionTenors_; j++)
            for (Size k = 0; k < nSwapTenors_; k++) {
                volSpreadsMatrix_[i][j][k] = volSpreads_[j * nSwapTenors_ + k][i]->value();
            }
    //! create volSpreadsInterpolator_
    for (Size i = 0; i < nStrikes_; i++) {
        if (!flatExtrapolation_)
            volSpreadsInterpolator_[i] =
                BilinearInterpolation(swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(),
                                      optionTimes_.end(), volSpreadsMatrix_[i]);
        else
            volSpreadsInterpolator_[i] = FlatExtrapolator2D(QuantLib::ext::make_shared<BilinearInterpolation>(
                swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(), optionTimes_.end(),
                volSpreadsMatrix_[i]));
        volSpreadsInterpolator_[i].enableExtrapolation();
    }
}

volSpreads()

const Matrix & volSpreads

(

Size

i

)

const

Definition at line 82 of file swaptionvolcube2.hpp.

{ return volSpreadsMatrix_[i]; }

smileSectionImpl() [1/2]

QuantLib::ext::shared_ptr< SmileSection > smileSectionImpl ( const Date &  optionDate, const Period &  swapTenor  ) const

override

Definition at line 101 of file swaptionvolcube2.cpp.

                                                                                                  {
    calculate();
    Rate atmForward = atmStrike(optionDate, swapTenor);
    Volatility referenceVol = volsAreSpreads_ ? atmVol_->volatility(optionDate, swapTenor, atmForward) : 0.0;
    Time optionTime = std::max(1E-6, timeFromReference(optionDate));
    Real exerciseTimeSqrt = std::sqrt(optionTime);
    std::vector<Real> strikes, stdDevs;
    strikes.reserve(nStrikes_);
    stdDevs.reserve(nStrikes_);
    Time length = swapLength(swapTenor);
    for (Size i = 0; i < nStrikes_; ++i) {
        strikes.push_back(atmForward + strikeSpreads_[i]);
        stdDevs.push_back(exerciseTimeSqrt * (referenceVol + volSpreadsInterpolator_[i](length, optionTime)));
    }
    Real shift = atmVol_->shift(optionTime, length);
    if (!flatExtrapolation_)
        return QuantLib::ext::shared_ptr<SmileSection>(new InterpolatedSmileSection<Linear>(
            optionTime, strikes, stdDevs, atmForward, Linear(), Actual365Fixed(), volatilityType(), shift));
    else
        return QuantLib::ext::shared_ptr<SmileSection>(new InterpolatedSmileSection<LinearFlat>(
            optionTime, strikes, stdDevs, atmForward, LinearFlat(), Actual365Fixed(), volatilityType(), shift));
}

Here is the caller graph for this function:

smileSectionImpl() [2/2]

QuantLib::ext::shared_ptr< SmileSection > smileSectionImpl ( Time  optionTime, Time  swapLength  ) const

override

Definition at line 88 of file swaptionvolcube2.cpp.

                                                                                                             {
 
    calculate();
    Date optionDate = optionDateFromTime(optionTime);
    Rounding rounder(0);
    Period swapTenor(static_cast<Integer>(rounder(swapLength * 12.0)), Months);
    // ensure that option date is valid fixing date
    optionDate = swapTenor > shortSwapIndexBase_->tenor()
                     ? swapIndexBase_->fixingCalendar().adjust(optionDate, Following)
                     : shortSwapIndexBase_->fixingCalendar().adjust(optionDate, Following);
    return smileSectionImpl(optionDate, swapTenor);
}

Here is the call graph for this function:

Member Data Documentation

flatExtrapolation_

const bool flatExtrapolation_

private

Definition at line 87 of file swaptionvolcube2.hpp.

volsAreSpreads_

const bool volsAreSpreads_

private

Definition at line 87 of file swaptionvolcube2.hpp.

volSpreadsInterpolator_

std::vector<Interpolation2D> volSpreadsInterpolator_

mutableprivate

Definition at line 88 of file swaptionvolcube2.hpp.

volSpreadsMatrix_

std::vector<Matrix> volSpreadsMatrix_

mutableprivate

Definition at line 89 of file swaptionvolcube2.hpp.