CorrelationCurve Class Reference

Wrapper class for building correlation structures. More...

#include <ored/marketdata/correlationcurve.hpp>

Collaboration diagram for CorrelationCurve:

Public Member Functions
Constructors
	CorrelationCurve ()
	Default constructor. More...
	CorrelationCurve (Date asof, CorrelationCurveSpec spec, const Loader &loader, const CurveConfigurations &curveConfigs, map< string, QuantLib::ext::shared_ptr< SwapIndex > > &swapIndices, map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, map< string, QuantLib::ext::shared_ptr< GenericYieldVolCurve > > &swaptionVolCurves)
	Detailed constructor. More...

Inspectors
CorrelationCurveSpec	spec_
QuantLib::ext::shared_ptr< QuantExt::CorrelationTermStructure >	corr_
class	CalibrationFunction
const CorrelationCurveSpec &	spec () const
const QuantLib::ext::shared_ptr< QuantExt::CorrelationTermStructure > &	corrTermStructure ()
void	calibrateCMSSpreadCorrelations (const QuantLib::ext::shared_ptr< CorrelationCurveConfig > &config, Date asof, const vector< Handle< Quote > > &prices, vector< Handle< Quote > > &quotes, QuantLib::ext::shared_ptr< QuantExt::CorrelationTermStructure > &curve, map< string, QuantLib::ext::shared_ptr< SwapIndex > > &swapIndices, map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, map< string, QuantLib::ext::shared_ptr< GenericYieldVolCurve > > &swaptionVolCurves)

Detailed Description

Wrapper class for building correlation structures.

Definition at line 45 of file correlationcurve.hpp.

Constructor & Destructor Documentation

CorrelationCurve() [1/2]

CorrelationCurve

(

)

Default constructor.

Definition at line 50 of file correlationcurve.hpp.

{}

CorrelationCurve() [2/2]

CorrelationCurve	(	Date	asof,
		CorrelationCurveSpec	spec,
		const Loader &	loader,
		const CurveConfigurations &	curveConfigs,
		map< string, QuantLib::ext::shared_ptr< SwapIndex > > &	swapIndices,
		map< string, QuantLib::ext::shared_ptr< YieldCurve > > &	yieldCurves,
		map< string, QuantLib::ext::shared_ptr< GenericYieldVolCurve > > &	swaptionVolCurves
	)

Detailed constructor.

Definition at line 193 of file correlationcurve.cpp.

                                                                                                                {
 
    try {
 
        const QuantLib::ext::shared_ptr<CorrelationCurveConfig>& config =
            curveConfigs.correlationCurveConfig(spec.curveConfigID());
 
        // build default correlation termstructure
        QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure> corr;
 
        if (config->quoteType() == MarketDatum::QuoteType::NONE) {
 
            corr = QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure>(
                new QuantExt::FlatCorrelation(0, config->calendar(), 0.0, config->dayCounter()));
 
        } else {
            QL_REQUIRE(config->dimension() == CorrelationCurveConfig::Dimension::ATM ||
                           config->dimension() == CorrelationCurveConfig::Dimension::Constant,
                       "Unsupported correlation curve building dimension");
 
            // Check if we are using a regular expression to select the quotes for the curve. If we are, the quotes should
            // contain exactly one element.
            auto wildcard = getUniqueWildcard(config->quotes());
 
            // vector with times, quotes pairs
            vector<pair<Real, Handle<Quote>>> quotePairs;
            // Different approaches depending on whether we are using a regex or searching for a list of explicit quotes.
            if (wildcard) {
                QL_REQUIRE(config->dimension() == CorrelationCurveConfig::Dimension::ATM, 
                    "CorrelationCurve: Wildcards only supported for curve dimension ATM");
                LOG("Have single quote with pattern " << wildcard->pattern());
 
                // Loop over quotes and process commodity option quotes matching pattern on asof
                for (const auto& md : loader.get(*wildcard, asof)) {
 
                    QL_REQUIRE(md->asofDate() == asof, "MarketDatum asofDate '" << md->asofDate() << "' <> asof '" << asof << "'");
 
                    auto q = QuantLib::ext::dynamic_pointer_cast<CorrelationQuote>(md);
                    if (q && q->quoteType() == config->quoteType()) {
 
                        TLOG("The quote " << q->name() << " matched the pattern");
 
                        Date expiryDate = getDateFromDateOrPeriod(q->expiry(), asof, config->calendar(), config->businessDayConvention());
                        if (expiryDate > asof) {
                            // add a <time, quote> pair
                            quotePairs.push_back(make_pair(config->dayCounter().yearFraction(asof, expiryDate), q->quote()));
                            TLOG("Added quote " << q->name() << ": (" << io::iso_date(expiryDate) << "," << fixed
                                << setprecision(9) << q->quote()->value() << ")");
                        }
                    }
                }
 
                if (quotePairs.size() == 0) {
                    Real corr = config->index1() == config->index2() ? 1.0 : 0.0;
                    WLOG("CorrelationCurve: No quotes found for correlation curve: "
                         << config->curveID() << ", continuing with correlation " << corr << ".");
                    corr_ = QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure>(
                        new QuantExt::FlatCorrelation(0, config->calendar(), corr, config->dayCounter()));
                    return;
                }
 
            } else {
                vector<Period> optionTenors = parseVectorOfValues<Period>(config->optionTenors(), &parsePeriod);
                quotePairs.resize(optionTenors.size());
                bool failed = false;
 
                // search market data loader for quotes, logging missing ones
                for (auto& q : config->quotes()) {
                    if (loader.has(q, asof)) {
                        QuantLib::ext::shared_ptr<CorrelationQuote> c =
                            QuantLib::ext::dynamic_pointer_cast<CorrelationQuote>(loader.get(q, asof));
 
                        Size i = std::find(optionTenors.begin(), optionTenors.end(), parsePeriod(c->expiry())) -
                            optionTenors.begin();
                        QL_REQUIRE(i < optionTenors.size(), "CorrelationCurve: correlation tenor not found for " << q);
 
                        Real time;
                        // add the expiry time - don't need for Constant curves
                        if (config->dimension() != CorrelationCurveConfig::Dimension::Constant) {
                            Date d = config->calendar().advance(asof, optionTenors[i], config->businessDayConvention());
                            time = config->dayCounter().yearFraction(asof, d);
                        }
                        quotePairs[i] = make_pair(time, c->quote());
 
                        TLOG("CorrelationCurve: Added quote " << c->name() << ", tenor " << optionTenors[i] << ", with value "
                            << fixed << setprecision(9) << c->quote()->value() );
                    } else {
                        DLOGGERSTREAM("could not find correlation quote " << q);
                        failed = true;
                    }
                }
                // fail if any quotes missing
                if (failed) {
                    QL_FAIL("could not build correlation curve");
                }
            }
            vector<Handle<Quote>> corrs;
 
            // sort the quotes
            std::sort(quotePairs.begin(), quotePairs.end());
            vector<Real> times;
            vector<Handle<Quote>> quotes;
            for (Size i = 0; i < quotePairs.size(); i++) {
                if (config->quoteType() == MarketDatum::QuoteType::RATE) {
                    corrs.push_back(quotePairs[i].second);
                } else {
                    Handle<Quote> q(QuantLib::ext::make_shared<SimpleQuote>(0));
                    corrs.push_back(q);
                }
                quotes.push_back(quotePairs[i].second);
                times.push_back(quotePairs[i].first);
            }                       
 
            // build correlation termstructure
            bool flat = (config->dimension() == CorrelationCurveConfig::Dimension::Constant || quotes.size() == 1);
            LOG("building " << (flat ? "flat" : "interpolated curve") << " correlation termstructure");
 
            if (flat) {
                corr = QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure>(
                    new QuantExt::FlatCorrelation(0, config->calendar(), corrs[0], config->dayCounter()));
 
                corr->enableExtrapolation(config->extrapolate());
            } else {
 
                corr = QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure>(
                    new QuantExt::InterpolatedCorrelationCurve<Linear>(times, corrs, config->dayCounter(),
                                                                       config->calendar()));
            }
 
            if (config->quoteType() == MarketDatum::QuoteType::PRICE) {
 
                if (config->correlationType() == CorrelationCurveConfig::CorrelationType::CMSSpread) {
                    calibrateCMSSpreadCorrelations(config, asof, quotes, corrs, corr, swapIndices,
                                                   yieldCurves, swaptionVolCurves);
                } else {
                    QL_FAIL("price calibration only supported for CMSSpread correlations");
                }
            }
 
            LOG("Returning correlation surface for config " << spec);
        }
        corr_ = corr;
    } catch (std::exception& e) {
        QL_FAIL("correlation curve building failed for curve " << spec.curveConfigID() << " on date "
                                                               << io::iso_date(asof) << ": " << e.what());
    } catch (...) {
        QL_FAIL("correlation curve building failed: unknown error");
    }
}

Here is the call graph for this function:

Member Function Documentation

spec()

const CorrelationCurveSpec & spec

(

)

const

Definition at line 60 of file correlationcurve.hpp.

{ return spec_; }

Here is the caller graph for this function:

corrTermStructure()

const QuantLib::ext::shared_ptr< QuantExt::CorrelationTermStructure > & corrTermStructure

(

)

Definition at line 62 of file correlationcurve.hpp.

{ return corr_; }

calibrateCMSSpreadCorrelations()

void calibrateCMSSpreadCorrelations ( const QuantLib::ext::shared_ptr< CorrelationCurveConfig > &  config, Date  asof, const vector< Handle< Quote > > &  prices, vector< Handle< Quote > > &  quotes, QuantLib::ext::shared_ptr< QuantExt::CorrelationTermStructure > &  curve, map< string, QuantLib::ext::shared_ptr< SwapIndex > > &  swapIndices, map< string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves, map< string, QuantLib::ext::shared_ptr< GenericYieldVolCurve > > &  swaptionVolCurves  )

private

Definition at line 93 of file correlationcurve.cpp.

                                                                                 {
 
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
    
    // build cms pricingengine
    string ccy = config->currency();
    string swaptionVol = "SwaptionVolatility/" + ccy + "/" + config->swaptionVolatility();
    auto it = swaptionVolCurves.find(swaptionVol);
 
    if (it == swaptionVolCurves.end())
        QL_FAIL("The swaption vol curve not found " << swaptionVol);
    Handle<SwaptionVolatilityStructure> vol(it->second->volTermStructure());
 
    string dc = "Yield/" + ccy + "/" + config->discountCurve();
    Handle<YieldTermStructure> yts;
    auto it2 = yieldCurves.find(dc);
    if (it2 != yieldCurves.end()) {
        yts = it2->second->handle();
    } else {
        QL_FAIL("The discount curve not found, " << dc);
    }
 
    Real lower = (vol->volatilityType() == ShiftedLognormal) ? 0.0001 : -2;
    Real upper = (vol->volatilityType() == ShiftedLognormal) ? 2.0000 : 2;
 
    LinearTsrPricer::Settings settings;
    settings.withRateBound(lower, upper);
 
    Real rev = 0;
    Handle<Quote> revQuote(QuantLib::ext::shared_ptr<Quote>(new SimpleQuote(rev)));
 
    QuantLib::ext::shared_ptr<QuantLib::CmsCouponPricer> cmsPricer =
        QuantLib::ext::make_shared<LinearTsrPricer>(vol, revQuote, yts, settings);
 
    // build cms spread pricer
    Handle<QuantExt::CorrelationTermStructure> ch(curve);
    QuantLib::ext::shared_ptr<FloatingRateCouponPricer> pricer =
        QuantLib::ext::make_shared<QuantExt::LognormalCmsSpreadPricer>(cmsPricer, ch, yts, 16);
 
    // build instruments
    auto it3 = swapIndices.find(config->index1());
    if (it3 == swapIndices.end())
        QL_FAIL("The swap index not found " << config->index1());
 
    QuantLib::ext::shared_ptr<SwapIndex> index1 = it3->second;
 
    auto it4 = swapIndices.find(config->index2());
    if (it4 == swapIndices.end())
        QL_FAIL("The swap index not found " << config->index2());
 
    QuantLib::ext::shared_ptr<SwapIndex> index2 = it4->second;
 
    vector<QuantLib::ext::shared_ptr<QuantExt::CmsCapHelper>> instruments;
 
    QuantLib::ext::shared_ptr<Convention> tmp = conventions->get(config->conventions());
    QL_REQUIRE(tmp, "no conventions found with id " << config->conventions());
 
    QuantLib::ext::shared_ptr<CmsSpreadOptionConvention> conv = QuantLib::ext::dynamic_pointer_cast<CmsSpreadOptionConvention>(tmp);
    QL_REQUIRE(conv != NULL, "CMS Correlation curves require CMSSpreadOption convention ");
    Period forwardStart = conv->forwardStart();
    Period spotDays = conv->spotDays();
    Period cmsTenor = conv->swapTenor();
    Natural fixingDays = conv->fixingDays();
    Calendar calendar = conv->calendar();
    DayCounter dcount = conv->dayCounter();
    BusinessDayConvention bdc = conv->rollConvention();
    vector<Period> optionTenors = parseVectorOfValues<Period>(config->optionTenors(), &parsePeriod);
 
    for (Size i = 0; i < prices.size(); i++) {
        QuantLib::ext::shared_ptr<QuantExt::CmsCapHelper> inst = QuantLib::ext::make_shared<QuantExt::CmsCapHelper>(
            asof, index1, index2, yts, prices[i], correlations[i], optionTenors[i], forwardStart, spotDays, cmsTenor,
            fixingDays, calendar, dcount, bdc, pricer, cmsPricer);
        instruments.push_back(inst);
    }
 
    // set up problem
    EndCriteria endCriteria(1000, 500, 1E-8, 1E-8, 1E-8);
    BoundaryConstraint constraint(-1, 1);
    vector<Real> weights(prices.size(), 1);
 
    Array prms(prices.size(), 0);
    vector<bool> all(prms.size(), false);
    Projection proj(prms, all);
    ProjectedConstraint pc(constraint, proj);
 
    QuantLib::ext::shared_ptr<OptimizationMethod> method = QuantLib::ext::make_shared<LevenbergMarquardt>(1E-8, 1E-8, 1E-8);
 
    CalibrationFunction c(correlations, instruments, weights, proj);
 
    Problem prob(c, pc, proj.project(prms));
 
    method->minimize(prob, endCriteria);
 
    Array result(prob.currentValue());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

CalibrationFunction

friend class CalibrationFunction

friend

Definition at line 76 of file correlationcurve.hpp.

Member Data Documentation

spec_

CorrelationCurveSpec spec_

private

Definition at line 71 of file correlationcurve.hpp.

corr_

QuantLib::ext::shared_ptr<QuantExt::CorrelationTermStructure> corr_

private

Definition at line 72 of file correlationcurve.hpp.