DefaultCurve Class Reference

Wrapper class for building Swaption volatility structures. More...

#include <ored/marketdata/defaultcurve.hpp>

Collaboration diagram for DefaultCurve:

Public Member Functions
Constructors
	DefaultCurve ()
	Default constructor. More...
	DefaultCurve (Date asof, DefaultCurveSpec spec, const Loader &loader, const CurveConfigurations &curveConfigs, map< string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves, map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &defaultCurves)
	Detailed constructor. More...

Inspectors
DefaultCurveSpec	spec_
QuantLib::ext::shared_ptr< QuantExt::CreditCurve >	curve_
Real	recoveryRate_
const DefaultCurveSpec &	spec () const
const QuantLib::ext::shared_ptr< QuantExt::CreditCurve > &	creditCurve () const
Real	recoveryRate ()
void	buildCdsCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const QuantLib::Date &asof, const DefaultCurveSpec &spec, const Loader &loader, std::map< std::string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)
	Build a default curve from CDS spread quotes. More...
void	buildHazardRateCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const QuantLib::Date &asof, const DefaultCurveSpec &spec, const Loader &loader)
	Build a default curve from hazard rate quotes. More...
void	buildBenchmarkCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const QuantLib::Date &asof, const DefaultCurveSpec &spec, const Loader &loader, std::map< std::string, QuantLib::ext::shared_ptr< YieldCurve > > &yieldCurves)
	Build a default curve implied from a spread over a benchmark curve. More...
void	buildMultiSectionCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const Date &asof, const DefaultCurveSpec &spec, const Loader &loader, map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &defaultCurves)
	Build a multi section curve. More...
void	buildTransitionMatrixCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const Date &asof, const DefaultCurveSpec &spec, const Loader &loader, map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &defaultCurves)
void	buildNullCurve (const std::string &curveID, const DefaultCurveConfig::Config &config, const Date &asof, const DefaultCurveSpec &spec)
	Build a null curve (null rate, null recovery) More...

Detailed Description

Wrapper class for building Swaption volatility structures.

Definition at line 46 of file defaultcurve.hpp.

Constructor & Destructor Documentation

DefaultCurve() [1/2]

DefaultCurve

(

)

Default constructor.

Definition at line 51 of file defaultcurve.hpp.

: recoveryRate_(QuantLib::Null<QuantLib::Real>()) {}

DefaultCurve() [2/2]

DefaultCurve	(	Date	asof,
		DefaultCurveSpec	spec,
		const Loader &	loader,
		const CurveConfigurations &	curveConfigs,
		map< string, QuantLib::ext::shared_ptr< YieldCurve > > &	yieldCurves,
		map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &	defaultCurves
	)

Detailed constructor.

Definition at line 226 of file defaultcurve.cpp.

                                                                                            {
    const QuantLib::ext::shared_ptr<DefaultCurveConfig>& configs = curveConfigs.defaultCurveConfig(spec.curveConfigID());
    bool built = false;
    std::string errors;
    for (auto const& config : configs->configs()) {
        try {
            recoveryRate_ = Null<Real>();
            if (!config.second.recoveryRateQuote().empty()) {
                // handle case where the recovery rate is hardcoded in the curve config
                if (!tryParseReal(config.second.recoveryRateQuote(), recoveryRate_)) {
                    Wildcard wc(config.second.recoveryRateQuote());
                    if (wc.hasWildcard()) {
                        for (auto const& q : loader.get(wc, asof)) {
                            if (wc.matches(q->name())) {
                                QL_REQUIRE(recoveryRate_ == Null<Real>(),
                                           "There is more than one recovery rate matching the pattern '" << wc.pattern()
                                                                                                         << "'.");
                                recoveryRate_ = q->quote()->value();
                            }
                        }
                    } else {
                        QL_REQUIRE(loader.has(config.second.recoveryRateQuote(), asof),
                                   "There is no market data for the requested recovery rate "
                                       << config.second.recoveryRateQuote());
                        recoveryRate_ = loader.get(config.second.recoveryRateQuote(), asof)->quote()->value();
                    }
                }
            }
            // Build the default curve of the requested type
            switch (config.second.type()) {
            case DefaultCurveConfig::Config::Type::SpreadCDS:
            case DefaultCurveConfig::Config::Type::Price:
                buildCdsCurve(configs->curveID(), config.second, asof, spec, loader, yieldCurves);
                break;
            case DefaultCurveConfig::Config::Type::HazardRate:
                buildHazardRateCurve(configs->curveID(), config.second, asof, spec, loader);
                break;
            case DefaultCurveConfig::Config::Type::Benchmark:
                buildBenchmarkCurve(configs->curveID(), config.second, asof, spec, loader, yieldCurves);
                break;
            case DefaultCurveConfig::Config::Type::MultiSection:
                buildMultiSectionCurve(configs->curveID(), config.second, asof, spec, loader, defaultCurves);
                break;
            case DefaultCurveConfig::Config::Type::TransitionMatrix:
                buildTransitionMatrixCurve(configs->curveID(), config.second, asof, spec, loader, defaultCurves);
                break;
            case DefaultCurveConfig::Config::Type::Null:
                buildNullCurve(configs->curveID(), config.second, asof, spec);
                break;
            default:
                QL_FAIL("The DefaultCurveConfig type " << static_cast<int>(config.second.type())
                                                       << " was not recognised");
            }
            built = true;
            break;
        } catch (exception& e) {
            std::ostringstream message;
            message << "build attempt failed for " << configs->curveID() << " using config with priority "
                    << config.first << ": " << e.what();
            DLOG(message.str());
            if (!errors.empty())
                errors += ", ";
            errors += message.str();
        }
    }
    QL_REQUIRE(built, "default curve building failed for " << spec.curveConfigID() << ": " << errors);
}

Here is the call graph for this function:

Member Function Documentation

spec()

const DefaultCurveSpec & spec

(

)

const

Definition at line 60 of file defaultcurve.hpp.

{ return spec_; }

Here is the caller graph for this function:

creditCurve()

const QuantLib::ext::shared_ptr< QuantExt::CreditCurve > & creditCurve

(

)

const

Definition at line 61 of file defaultcurve.hpp.

{ return curve_; }

recoveryRate()

Real recoveryRate

(

)

Definition at line 62 of file defaultcurve.hpp.

{ return recoveryRate_; }

Here is the caller graph for this function:

buildCdsCurve()

void buildCdsCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const QuantLib::Date &  asof, const DefaultCurveSpec &  spec, const Loader &  loader, std::map< std::string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Build a default curve from CDS spread quotes.

Definition at line 297 of file defaultcurve.cpp.

                                                                                              {
 
    LOG("Start building default curve of type SpreadCDS for curve " << curveID);
 
    QL_REQUIRE(config.type() == DefaultCurveConfig::Config::Type::SpreadCDS ||
                   config.type() == DefaultCurveConfig::Config::Type::Price,
               "DefaultCurve::buildCdsCurve expected a default curve configuration with type SpreadCDS/Price");
    QL_REQUIRE(recoveryRate_ != Null<Real>(), "DefaultCurve: recovery rate needed to build SpreadCDS curve");
 
    // Get the CDS curve conventions
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
    QL_REQUIRE(conventions->has(config.conventionID()), "No conventions found with id " << config.conventionID());
    QuantLib::ext::shared_ptr<CdsConvention> cdsConv =
        QuantLib::ext::dynamic_pointer_cast<CdsConvention>(conventions->get(config.conventionID()));
    QL_REQUIRE(cdsConv, "SpreadCDS curves require CDS convention");
 
    // Get the discount curve for use in the CDS spread curve bootstrap
    auto it = yieldCurves.find(config.discountCurveID());
    QL_REQUIRE(it != yieldCurves.end(), "The discount curve, " << config.discountCurveID()
                                                               << ", required in the building of the curve, "
                                                               << spec.name() << ", was not found.");
    Handle<YieldTermStructure> discountCurve = it->second->handle();
 
    // Get the CDS spread / price curve quotes
    set<QuoteData> quotes = getConfiguredQuotes(curveID, config, asof, loader);
 
    // Set up ref data for the curve, except runningSpread which is set below
    QuantExt::CreditCurve::RefData refData;
    refData.indexTerm = config.indexTerm();
    refData.startDate = config.startDate();
    refData.tenor = Period(cdsConv->frequency());
    refData.calendar = cdsConv->calendar();
    refData.convention = cdsConv->paymentConvention();
    refData.termConvention = cdsConv->paymentConvention();
    refData.rule = cdsConv->rule();
    refData.payConvention = cdsConv->paymentConvention();
    refData.dayCounter = cdsConv->dayCounter();
    refData.lastPeriodDayCounter = cdsConv->lastPeriodDayCounter();
    refData.cashSettlementDays = cdsConv->upfrontSettlementDays();
 
    // If the configuration instructs us to imply a default from the market data, we do it here.
    if (config.implyDefaultFromMarket() && *config.implyDefaultFromMarket()) {
        if (recoveryRate_ != Null<Real>() && quotes.empty()) {
            // Assume entity is in default, between event determination date and auction date. Build a survival
            // probability curve with value 0.0 tomorrow to approximate this and allow dependent instruments to price.
            // Need to use small but positive numbers to avoid downstream issues with log linear survivals e.g. below
            // and in places like ScenarioSimMarket.
            vector<Date> dates{asof, asof + 1 * Years, asof + 10 * Years};
            vector<Real> survivalProbs{1.0, 1e-16, 1e-18};
            curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(
                Handle<DefaultProbabilityTermStructure>(
                    QuantLib::ext::make_shared<QuantExt::InterpolatedSurvivalProbabilityCurve<LogLinear>>(
                        dates, survivalProbs, config.dayCounter(), Calendar(), std::vector<Handle<Quote>>(),
                        std::vector<Date>(), LogLinear())),
                discountCurve, Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(recoveryRate_)), refData);
            curve_->curve()->enableExtrapolation();
            WLOG("DefaultCurve: recovery rate found but no CDS quotes for "
                 << curveID << " and "
                 << "ImplyDefaultFromMarket is true. Curve built that gives default immediately.");
            return;
        }
    } else {
        QL_REQUIRE(!quotes.empty(), "No market points found for CDS curve config " << curveID);
    }
 
    // Create the CDS instrument helpers, only keep alive helpers
    vector<QuantLib::ext::shared_ptr<QuantExt::DefaultProbabilityHelper>> helpers;
    std::map<QuantLib::Date, QuantLib::Period> helperQuoteTerms;
    Real runningSpread = Null<Real>();
    QuantExt::CreditDefaultSwap::ProtectionPaymentTime ppt = cdsConv->paysAtDefaultTime()
                                                                 ? QuantExt::CreditDefaultSwap::atDefault
                                                                 : QuantExt::CreditDefaultSwap::atPeriodEnd;
 
    if (config.type() == DefaultCurveConfig::Config::Type::SpreadCDS) {
        for (auto quote : quotes) {
            QuantLib::ext::shared_ptr<SpreadCdsHelper> tmp;
            try {
                tmp = QuantLib::ext::make_shared<SpreadCdsHelper>(
                    quote.value, quote.term, cdsConv->settlementDays(), cdsConv->calendar(), cdsConv->frequency(),
                    cdsConv->paymentConvention(), cdsConv->rule(), cdsConv->dayCounter(), recoveryRate_, discountCurve,
                    cdsConv->settlesAccrual(), ppt, config.startDate(), cdsConv->lastPeriodDayCounter());
 
            } catch (exception& e) {
                if (quote.term == Period(0, Months)) {
                    WLOG("DefaultCurve:: Cannot add quote of term 0M to CDS curve " << curveID << " for asof date "
                                                                                    << asof);
                } else {
                    QL_FAIL("DefaultCurve:: Failed to add quote of term " << quote.term << " to CDS curve " << curveID
                                                                          << " for asof date " << asof
                                                                          << ", with error: " << e.what());
                }
            }
            if (tmp) {
                if (tmp->latestDate() > asof) {
                    helpers.push_back(tmp);
                    runningSpread = config.runningSpread();
                }
                helperQuoteTerms[tmp->latestDate()] = quote.term;
            }
        }
    } else {
        for (auto quote : quotes) {
            // If there is no running spread encoded in the quote, the config must have one.
            runningSpread = quote.runningSpread;
            if (runningSpread == Null<Real>()) {
                QL_REQUIRE(config.runningSpread() != Null<Real>(),
                           "A running spread was not provided in the quote "
                               << "string so it must be provided in the config for CDS upfront curve " << curveID);
                runningSpread = config.runningSpread();
            }
            auto tmp = QuantLib::ext::make_shared<UpfrontCdsHelper>(
                quote.value, runningSpread, quote.term, cdsConv->settlementDays(), cdsConv->calendar(),
                cdsConv->frequency(), cdsConv->paymentConvention(), cdsConv->rule(), cdsConv->dayCounter(),
                recoveryRate_, discountCurve, cdsConv->upfrontSettlementDays(), cdsConv->settlesAccrual(), ppt,
                config.startDate(), cdsConv->lastPeriodDayCounter());
            if (tmp->latestDate() > asof) {
                helpers.push_back(tmp);
            }
            helperQuoteTerms[tmp->latestDate()] = quote.term;
        }
    }
 
    QL_REQUIRE(!helpers.empty(), "DefaultCurve: no alive quotes found.");
 
    refData.runningSpread = runningSpread;
 
    // Ensure that the helpers are sorted. This is done in IterativeBootstrap, but we need
    // a sorted instruments vector in the code here as well.
    std::sort(helpers.begin(), helpers.end(), QuantLib::detail::BootstrapHelperSorter());
 
    // Get configuration values for bootstrap
    Real accuracy = config.bootstrapConfig().accuracy();
    Real globalAccuracy = config.bootstrapConfig().globalAccuracy();
    bool dontThrow = config.bootstrapConfig().dontThrow();
    Size maxAttempts = config.bootstrapConfig().maxAttempts();
    Real maxFactor = config.allowNegativeRates() ? config.bootstrapConfig().maxFactor() : 1.0;
    Real minFactor = config.bootstrapConfig().minFactor();
    Size dontThrowSteps = config.bootstrapConfig().dontThrowSteps();
 
    typedef PiecewiseDefaultCurve<QuantExt::SurvivalProbability, LogLinear, QuantExt::IterativeBootstrap> SpCurve;
    SpCurve::bootstrap_type btconfig(accuracy, globalAccuracy, dontThrow, maxAttempts, maxFactor,
                                                   minFactor, dontThrowSteps);
    QuantLib::ext::shared_ptr<DefaultProbabilityTermStructure> qlCurve;
 
    if (config.indexTerm() != 0 * Days) {
 
        // build flat index curve picking a quote with identical term as configured if possible
        // otherwise build interpolated curve using the existing quotes
 
        std::vector<Real> helperTermTimes;
        for (auto const& h : helpers) {
            helperTermTimes.push_back(QuantExt::periodToTime(helperQuoteTerms[h->latestDate()]));
        }
 
        Real t = QuantExt::periodToTime(config.indexTerm());
        Size helperIndex_m, helperIndex_p;
        Real alpha;
        std::tie(helperIndex_m, helperIndex_p, alpha) = QuantExt::interpolationIndices(helperTermTimes, t);
 
        auto tmp1 = QuantLib::ext::make_shared<SpCurve>(
            asof, std::vector<QuantLib::ext::shared_ptr<QuantExt::DefaultProbabilityHelper>>{helpers[helperIndex_m]},
            config.dayCounter(), LogLinear(), btconfig);
        Date d1 = helpers[helperIndex_m]->pillarDate();
        Real p1 = tmp1->survivalProbability(d1);
        auto tmp1i = QuantLib::ext::make_shared<QuantExt::InterpolatedSurvivalProbabilityCurve<LogLinear>>(
            std::vector<Date>{asof, d1}, std::vector<Real>{1.0, p1}, config.dayCounter(), Calendar(),
            std::vector<Handle<Quote>>(), std::vector<Date>(), LogLinear(), config.allowNegativeRates());
 
        if (close_enough(alpha, 1.0)) {
            qlCurve = tmp1i;
        } else {
            auto tmp2 = QuantLib::ext::make_shared<SpCurve>(
                asof, std::vector<QuantLib::ext::shared_ptr<QuantExt::DefaultProbabilityHelper>>{helpers[helperIndex_p]},
                config.dayCounter(), LogLinear(), btconfig);
            Date d2 = helpers[helperIndex_p]->pillarDate();
            Real p2 = tmp2->survivalProbability(d2);
            auto tmp2i = QuantLib::ext::make_shared<QuantExt::InterpolatedSurvivalProbabilityCurve<LogLinear>>(
                std::vector<Date>{asof, d2}, std::vector<Real>{1.0, p2}, config.dayCounter(), Calendar(),
                std::vector<Handle<Quote>>(), std::vector<Date>(), LogLinear(), config.allowNegativeRates());
            tmp1i->enableExtrapolation();
            tmp2i->enableExtrapolation();
            qlCurve = QuantLib::ext::make_shared<QuantExt::TermInterpolatedDefaultCurve>(
                Handle<DefaultProbabilityTermStructure>(tmp1i), Handle<DefaultProbabilityTermStructure>(tmp2i), alpha);
        }
 
    } else {
 
        // build single name curve
 
        QuantLib::ext::shared_ptr<DefaultProbabilityTermStructure> tmp = QuantLib::ext::make_shared<SpCurve>(
            asof, helpers, config.dayCounter(), LogLinear(),
            QuantExt::IterativeBootstrap<SpCurve>(accuracy, globalAccuracy, dontThrow, maxAttempts, maxFactor,
                                                  minFactor, dontThrowSteps));
 
        // As for yield curves we need to copy the piecewise curve because on eval date changes the relative date
        // helpers with trigger a bootstrap.
        vector<Date> dates;
        vector<Real> survivalProbs;
        dates.push_back(asof);
        survivalProbs.push_back(1.0);
 
        for (Size i = 0; i < helpers.size(); ++i) {
            if (helpers[i]->latestDate() > asof) {
                Date pillarDate = helpers[i]->pillarDate();
                Probability sp = tmp->survivalProbability(pillarDate);
 
                // In some cases the bootstrapped survival probability at one tenor will be `close` to that at a
                // previous tenor. Here we don't add that survival probability and date to avoid issues when creating
                // the InterpolatedSurvivalProbabilityCurve below.
                if (!survivalProbs.empty() && close(survivalProbs.back(), sp)) {
                    DLOG("Survival probability for curve " << spec.name() << " at date " << io::iso_date(pillarDate)
                                                           << " is the same as that at previous date "
                                                           << io::iso_date(dates.back()) << " so skipping it.");
                    continue;
                }
 
                dates.push_back(pillarDate);
                survivalProbs.push_back(sp);
                TLOG(io::iso_date(pillarDate) << "," << fixed << setprecision(9) << sp);
            }
        }
        if (dates.size() == 1) {
            // We might have removed points above. To make the interpolation work, we need at least two points though.
            dates.push_back(dates.back() + 1);
            survivalProbs.push_back(survivalProbs.back());
        }
        qlCurve = QuantLib::ext::make_shared<QuantExt::InterpolatedSurvivalProbabilityCurve<LogLinear>>(
            dates, survivalProbs, config.dayCounter(), Calendar(), std::vector<Handle<Quote>>(), std::vector<Date>(),
            LogLinear(), config.allowNegativeRates());
    }
 
    if (config.extrapolation()) {
        qlCurve->enableExtrapolation();
        DLOG("DefaultCurve: Enabled Extrapolation");
    }
 
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(Handle<DefaultProbabilityTermStructure>(qlCurve), discountCurve,
                                                       Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(recoveryRate_)),
                                                       refData);
 
    LOG("Finished building default curve of type SpreadCDS for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildHazardRateCurve()

void buildHazardRateCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const QuantLib::Date &  asof, const DefaultCurveSpec &  spec, const Loader &  loader  )

private

Build a default curve from hazard rate quotes.

Definition at line 542 of file defaultcurve.cpp.

                                                                                                              {
 
    LOG("Start building default curve of type HazardRate for curve " << curveID);
 
    QL_REQUIRE(config.type() == DefaultCurveConfig::Config::Type::HazardRate,
               "DefaultCurve::buildHazardRateCurve expected a default curve configuration with type HazardRate");
 
    // Get the hazard rate curve conventions
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
    QL_REQUIRE(conventions->has(config.conventionID()), "No conventions found with id " << config.conventionID());
    QuantLib::ext::shared_ptr<CdsConvention> cdsConv =
        QuantLib::ext::dynamic_pointer_cast<CdsConvention>(conventions->get(config.conventionID()));
    QL_REQUIRE(cdsConv, "HazardRate curves require CDS convention");
 
    // Get the hazard rate quotes
    set<QuoteData> quotes = getConfiguredQuotes(curveID, config, asof, loader);
 
    // Build the hazard rate curve
    Calendar cal = cdsConv->calendar();
    vector<Date> dates;
    vector<Real> quoteValues;
 
    // If first term is not zero, add asof point
    if (quotes.begin()->term != 0 * Days) {
        LOG("DefaultCurve: add asof (" << asof << "), hazard rate " << quotes.begin()->value << ", as not given");
        dates.push_back(asof);
        quoteValues.push_back(quotes.begin()->value);
    }
 
    for (auto quote : quotes) {
        dates.push_back(cal.advance(asof, quote.term, Following, false));
        quoteValues.push_back(quote.value);
    }
 
    LOG("DefaultCurve: set up interpolated hazard rate curve");
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(
        Handle<DefaultProbabilityTermStructure>(QuantLib::ext::make_shared<QuantExt::InterpolatedHazardRateCurve<BackwardFlat>>(
            dates, quoteValues, config.dayCounter(), BackwardFlat(), config.allowNegativeRates())));
 
    if (config.extrapolation()) {
        curve_->curve()->enableExtrapolation();
        DLOG("DefaultCurve: Enabled Extrapolation");
    }
 
    if (recoveryRate_ == Null<Real>()) {
        LOG("DefaultCurve: setting recovery rate to 0.0 for hazard rate curve, because none is given.");
        recoveryRate_ = 0.0;
    }
 
    // Force bootstrap so that errors are thrown during the build, not later
    curve_->curve()->survivalProbability(QL_EPSILON);
 
    LOG("Finished building default curve of type HazardRate for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildBenchmarkCurve()

void buildBenchmarkCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const QuantLib::Date &  asof, const DefaultCurveSpec &  spec, const Loader &  loader, std::map< std::string, QuantLib::ext::shared_ptr< YieldCurve > > &  yieldCurves  )

private

Build a default curve implied from a spread over a benchmark curve.

Definition at line 598 of file defaultcurve.cpp.

                                                                                                    {
 
    LOG("Start building default curve of type Benchmark for curve " << curveID);
 
    QL_REQUIRE(config.type() == DefaultCurveConfig::Config::Type::Benchmark,
               "DefaultCurve::buildBenchmarkCurve expected a default curve configuration with type Benchmark");
 
    if (recoveryRate_ == Null<Real>())
        recoveryRate_ = 0.0;
 
    // Populate benchmark yield curve
    auto it = yieldCurves.find(config.benchmarkCurveID());
    QL_REQUIRE(it != yieldCurves.end(), "The benchmark curve, " << config.benchmarkCurveID()
                                                                << ", required in the building of the curve, "
                                                                << spec.name() << ", was not found.");
    QuantLib::ext::shared_ptr<YieldCurve> benchmarkCurve = it->second;
 
    // Populate source yield curve
    it = yieldCurves.find(config.sourceCurveID());
    QL_REQUIRE(it != yieldCurves.end(), "The source curve, " << config.sourceCurveID()
                                                             << ", required in the building of the curve, "
                                                             << spec.name() << ", was not found.");
    QuantLib::ext::shared_ptr<YieldCurve> sourceCurve = it->second;
 
    // Parameters from the configuration
    vector<Period> pillars = parseVectorOfValues<Period>(config.pillars(), &parsePeriod);
    Calendar cal = config.calendar();
    Size spotLag = config.spotLag();
 
    // Create the implied survival curve
    vector<Date> dates;
    vector<Real> impliedSurvProb;
    Date spot = cal.advance(asof, spotLag * Days);
    for (Size i = 0; i < pillars.size(); ++i) {
        dates.push_back(cal.advance(spot, pillars[i]));
        Real tmp = dates[i] == asof
                       ? 1.0
                       : sourceCurve->handle()->discount(dates[i]) / benchmarkCurve->handle()->discount(dates[i]);
        // if a non-zero recovery rate is given, we adjust the implied surv probability according to a market value
        // recovery model (see the documentation of the benchmark curve in the user guide for more details)
        impliedSurvProb.push_back(std::pow(tmp, 1.0 / (1.0 - recoveryRate_)));
    }
    QL_REQUIRE(dates.size() > 0, "DefaultCurve (Benchmark): no dates given");
 
    // Insert SP = 1.0 at asof if asof date is not in the pillars
    if (dates[0] != asof) {
        dates.insert(dates.begin(), asof);
        impliedSurvProb.insert(impliedSurvProb.begin(), 1.0);
    }
 
    LOG("DefaultCurve: set up interpolated surv prob curve as yield over benchmark");
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(Handle<DefaultProbabilityTermStructure>(
        QuantLib::ext::make_shared<QuantExt::InterpolatedSurvivalProbabilityCurve<LogLinear>>(
            dates, impliedSurvProb, config.dayCounter(), Calendar(), std::vector<Handle<Quote>>(), std::vector<Date>(),
            LogLinear(), config.allowNegativeRates())));
 
    if (config.extrapolation()) {
        curve_->curve()->enableExtrapolation();
        DLOG("DefaultCurve: Enabled Extrapolation");
    }
 
    // Force bootstrap so that errors are thrown during the build, not later
    curve_->curve()->survivalProbability(QL_EPSILON);
 
    LOG("Finished building default curve of type Benchmark for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildMultiSectionCurve()

void buildMultiSectionCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const Date &  asof, const DefaultCurveSpec &  spec, const Loader &  loader, map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &  defaultCurves  )

private

Build a multi section curve.

Definition at line 667 of file defaultcurve.cpp.

                                                                                                           {
    LOG("Start building default curve of type MultiSection for curve " << curveID);
 
    std::vector<Handle<DefaultProbabilityTermStructure>> curves;
    std::vector<Handle<Quote>> recoveryRates;
    std::vector<Date> switchDates;
 
    for (auto const& s : config.multiSectionSourceCurveIds()) {
        auto it = defaultCurves.find(s);
        QL_REQUIRE(it != defaultCurves.end(),
                   "The multi section source curve " << s << " required for " << spec.name() << " was not found.");
        curves.push_back(Handle<DefaultProbabilityTermStructure>(it->second->creditCurve()->curve()));
        recoveryRates.push_back(Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(it->second->recoveryRate())));
    }
 
    for (auto const& d : config.multiSectionSwitchDates()) {
        switchDates.push_back(parseDate(d));
    }
 
    Handle<Quote> recoveryRate(QuantLib::ext::make_shared<SimpleQuote>(recoveryRate_));
    LOG("DefaultCurve: set up multi section curve with " << curves.size() << " sections");
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(
        Handle<DefaultProbabilityTermStructure>(QuantLib::ext::make_shared<QuantExt::MultiSectionDefaultCurve>(
            curves, recoveryRates, switchDates, recoveryRate, config.dayCounter(), config.extrapolation())));
 
    LOG("Finished building default curve of type MultiSection for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildTransitionMatrixCurve()

void buildTransitionMatrixCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const Date &  asof, const DefaultCurveSpec &  spec, const Loader &  loader, map< string, QuantLib::ext::shared_ptr< DefaultCurve > > &  defaultCurves  )

private

Definition at line 697 of file defaultcurve.cpp.

                                                                                                               {
    LOG("Start building default curve of type TransitionMatrix for curve " << curveID);
    Size dim = config.states().size();
    QL_REQUIRE(dim >= 2,
               "DefaultCurve::buildTransitionMatrixCurve(): transition matrix dimension >= 2 required, found " << dim);
    Matrix transitionMatrix(dim, dim, Null<Real>());
    map<string, Size> stateIndex;
    for (Size i = 0; i < config.states().size(); ++i)
        stateIndex[config.states()[i]] = i;
    QL_REQUIRE(!config.cdsQuotes().empty(), "DefaultCurve::buildTransitionMatrixCurve(): not quotes given.");
    std::vector<std::string> tmp;
    std::transform(config.cdsQuotes().begin(), config.cdsQuotes().end(), std::back_inserter(tmp),
                   [](const std::pair<std::string, bool>& p) { return p.first; });
    auto wildcard = getUniqueWildcard(tmp);
    std::set<QuantLib::ext::shared_ptr<MarketDatum>> mdData;
    if (wildcard) {
        mdData = loader.get(*wildcard, asof);
    } else {
        for (auto const& q : config.cdsQuotes()) {
            if (auto m = loader.get(q, asof))
                mdData.insert(m);
        }
    }
    for (const auto& md : mdData) {
        QL_REQUIRE(md->instrumentType() == MarketDatum::InstrumentType::RATING,
                   "DefaultCurve::buildTransitionMatrixCurve(): quote instrument type must be RATING.");
        QuantLib::ext::shared_ptr<TransitionProbabilityQuote> q = QuantLib::ext::dynamic_pointer_cast<TransitionProbabilityQuote>(md);
        Size i = stateIndex[q->fromRating()];
        Size j = stateIndex[q->toRating()];
        transitionMatrix[i][j] = q->quote()->value();
    }
    for (Size i = 0; i < dim; ++i) {
        for (Size j = 0; j < dim; ++j) {
            QL_REQUIRE(transitionMatrix[i][j] != Null<Real>(),
                       "DefaultCurve::buildTransitionMatrixCurve():matrix element "
                           << config.states()[i] << " -> " << config.states()[j] << " missing in market data");
        }
    }
    Size initialStateIndex = stateIndex[config.initialState()];
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(
        Handle<DefaultProbabilityTermStructure>(QuantLib::ext::make_shared<QuantExt::GeneratorDefaultProbabilityTermStructure>(
            QuantExt::GeneratorDefaultProbabilityTermStructure::MatrixType::Transition, transitionMatrix,
            initialStateIndex, asof)));
    if (recoveryRate_ == Null<Real>())
        recoveryRate_ = 0.0;
    LOG("Finished building default curve of type TransitionMatrix for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

buildNullCurve()

void buildNullCurve ( const std::string &  curveID, const DefaultCurveConfig::Config &  config, const Date &  asof, const DefaultCurveSpec &  spec  )

private

Build a null curve (null rate, null recovery)

Definition at line 747 of file defaultcurve.cpp.

                                                                                  {
    LOG("Start building null default curve for " << curveID);
    curve_ = QuantLib::ext::make_shared<QuantExt::CreditCurve>(Handle<DefaultProbabilityTermStructure>(
        QuantLib::ext::make_shared<QuantLib::FlatHazardRate>(asof, 0.0, config.dayCounter())));
    recoveryRate_ = 0.0;
    LOG("Finished building default curve of type Null for curve " << curveID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

spec_

DefaultCurveSpec spec_

private

Definition at line 65 of file defaultcurve.hpp.

curve_

QuantLib::ext::shared_ptr<QuantExt::CreditCurve> curve_

private

Definition at line 66 of file defaultcurve.hpp.

recoveryRate_

Real recoveryRate_

private

Definition at line 67 of file defaultcurve.hpp.