BondSpreadImply Class Reference

#include <ored/marketdata/bondspreadimply.hpp>

Collaboration diagram for BondSpreadImply:

Static Public Member Functions
static std::map< std::string, QuantLib::ext::shared_ptr< Security > >	requiredSecurities (const Date &asof, const QuantLib::ext::shared_ptr< TodaysMarketParameters > &params, const QuantLib::ext::shared_ptr< CurveConfigurations > &curveConfigs, const Loader &loader, const bool continueOnError=false, const std::string &excludeRegex=std::string())
static QuantLib::ext::shared_ptr< Loader >	implyBondSpreads (const std::map< std::string, QuantLib::ext::shared_ptr< Security > > &securities, const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager, const QuantLib::ext::shared_ptr< Market > &market, const QuantLib::ext::shared_ptr< EngineData > &engineData, const std::string &configuration, const IborFallbackConfig &iborFallbackConfig)

Static Private Member Functions
static Real	implySpread (const std::string &securityId, const Real cleanPrice, const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager, const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::ext::shared_ptr< SimpleQuote > &spreadQuote, const std::string &configuration)
	helper function that computes a single implied spread for a bond More...

Detailed Description

Definition at line 35 of file bondspreadimply.hpp.

Member Function Documentation

requiredSecurities()

std::map< std::string, QuantLib::ext::shared_ptr< Security > > requiredSecurities ( const Date &  asof, const QuantLib::ext::shared_ptr< TodaysMarketParameters > &  params, const QuantLib::ext::shared_ptr< CurveConfigurations > &  curveConfigs, const Loader &  loader, const bool  continueOnError = false, const std::string &  excludeRegex = std::string()  )

static

Determine the securities that require a spread imply and return a map securityID => security containing them. If excludeRegex is non-empty security ids that match excludeRegex are excluded from the returned list.

Definition at line 39 of file bondspreadimply.cpp.

                                                                                               {
    std::regex excludePattern;
    if (!excludeRegex.empty())
        excludePattern = std::regex(excludeRegex);
 
    std::map<std::string, QuantLib::ext::shared_ptr<Security>> securities;
    for (const auto& configuration : params->configurations()) {
        LOG("identify securities that require a spread imply for configuration " << configuration.first);
 
        /* Loop over the security curve specs, do the spread imply where we have a price, but no spread
           and and store the calculated spread in the MarketImpl container */
        for (const auto& it : params->curveSpecs(configuration.first)) {
            auto securityspec = QuantLib::ext::dynamic_pointer_cast<SecuritySpec>(parseCurveSpec(it));
            if (securityspec) {
                std::string securityId = securityspec->securityID();
                if (std::regex_match(securityId, excludePattern)) {
                    DLOG("skip " << securityId << " because it matches the exclude regex (" << excludeRegex << ")");
                    continue;
                }
                if (curveConfigs->hasSecurityConfig(securityId)) {
                    if (curveConfigs->securityConfig(securityId)->spreadQuote().empty()) {
                        DLOG("no spread quote configuraed, skip security " << securityId);
                        continue;
                    }
                    QuantLib::ext::shared_ptr<Security> security;
                    try {
                        security = QuantLib::ext::make_shared<Security>(asof, *securityspec, loader, *curveConfigs);
                    } catch (const std::exception& e) {
                        if (continueOnError) {
                            StructuredCurveErrorMessage(securityId, "Bond spread imply failed",
                                                        "Will continue the calculations with a zero security spread: " +
                                                            std::string(e.what()))
                                .log();
                            continue;
                        } else {
                            QL_FAIL("Cannot process security " << securityId << " " << e.what());
                        }
                    }
                    if (security->spread().empty()) {
                        if (!security->price().empty()) {
                            LOG("empty spread, non-empty price: will imply spread for security " << securityId);
                            securities[securityId] = security;
                        } else {
                            DLOG("empty spread, empty price: spread will be left empty for security " << securityId);
                            StructuredCurveErrorMessage("Security/" + securityId, "Missing security spread",
                                                        "No security spread or bond price to imply the spread is "
                                                        "given. Will proceed assuming a zero spread.")
                                .log();
                        }
                    } else {
                        if (!security->price().empty()) {
                            WLOG("non-empty spread, non-empty price, will not overwrite existing spread for security "
                                 << securityId);
                        } else {
                            DLOG("non-empty spread, empty price, do nothing for security " << securityId);
                        }
                    }
                } else {
                    WLOG("do not have security curve config for '" << securityId
                                                                   << "' - skip this security in spread imply");
                }
            }
        }
    }
    LOG("got " << securities.size() << " securities");
    return securities;
}

Here is the call graph for this function:

implyBondSpreads()

QuantLib::ext::shared_ptr< Loader > implyBondSpreads ( const std::map< std::string, QuantLib::ext::shared_ptr< Security > > &  securities, const QuantLib::ext::shared_ptr< ReferenceDataManager > &  referenceDataManager, const QuantLib::ext::shared_ptr< Market > &  market, const QuantLib::ext::shared_ptr< EngineData > &  engineData, const std::string &  configuration, const IborFallbackConfig &  iborFallbackConfig  )

static

Imply bond spreads and add them to the loader.

Definition at line 110 of file bondspreadimply.cpp.

                                                                                                                {
 
    LOG("run bond spread imply");
 
    Settings::instance().evaluationDate() = market->asofDate();
 
    // build engine factory against which we build the bonds
    map<MarketContext, string> configurations;
    configurations[MarketContext::pricing] = configuration;
    auto spreadImplyMarket = QuantLib::ext::make_shared<BondSpreadImplyMarket>(market);
    auto edCopy = QuantLib::ext::make_shared<EngineData>(*engineData);
    edCopy->globalParameters()["RunType"] = "BondSpreadImply";
    auto engineFactory = QuantLib::ext::make_shared<EngineFactory>(edCopy, spreadImplyMarket, configurations,
                                                           referenceDataManager, iborFallbackConfig);
 
    // imply spreads and store the generate market data
 
    std::map<std::string, QuantLib::ext::shared_ptr<MarketDatum>> generatedSpreads;
    for (auto const& sec : securities) {
        auto storedSpread = generatedSpreads.find(sec.first);
        if (storedSpread == generatedSpreads.end()) {
            try {
                auto impliedSpread = QuantLib::ext::make_shared<SecuritySpreadQuote>(
                    implySpread(sec.first, sec.second->price()->value(), referenceDataManager, engineFactory,
                                spreadImplyMarket->spreadQuote(sec.first), configuration),
                    market->asofDate(), "BOND/YIELD_SPREAD/" + sec.first, sec.first);
                generatedSpreads[sec.first] = impliedSpread;
                LOG("spread imply succeded for security " << sec.first << ", got " << std::setprecision(10)
                                                          << impliedSpread->quote()->value());
            } catch (const std::exception& e) {
                StructuredCurveErrorMessage(
                    sec.first,
                    "bond spread imply failed (target price = " + std::to_string(sec.second->price()->value()) +
                        "). Will continue the calculations with a zero security spread.",
                    e.what()).log();
            }
        }
    }
 
    // add generated market data to loader and return the loader
 
    auto loader = QuantLib::ext::make_shared<InMemoryLoader>();
 
    for (auto const& s : generatedSpreads) {
        DLOG("adding market datum " << s.second->name() << " (" << s.second->quote()->value() << ") for asof "
                                    << market->asofDate() << " to loader");
        loader->add(market->asofDate(), s.second->name(), s.second->quote()->value());
    }
 
    LOG("bond spread imply finished.");
    return loader;
}

Here is the call graph for this function:

implySpread()

Real implySpread ( const std::string &  securityId, const Real  cleanPrice, const QuantLib::ext::shared_ptr< ReferenceDataManager > &  referenceDataManager, const QuantLib::ext::shared_ptr< EngineFactory > &  engineFactory, const QuantLib::ext::shared_ptr< SimpleQuote > &  spreadQuote, const std::string &  configuration  )

staticprivate

helper function that computes a single implied spread for a bond

Definition at line 167 of file bondspreadimply.cpp.

                                                                                                                         {
 
    // checks, build bond from reference data
 
    QL_REQUIRE(referenceDataManager, "no reference data manager given");
 
    auto b = BondFactory::instance().build(engineFactory, referenceDataManager, securityId);
    Real adj = b.priceQuoteMethod == QuantExt::BondIndex::PriceQuoteMethod::CurrencyPerUnit
                   ? 1.0 / b.priceQuoteBaseValue
                   : 1.0;
 
    Real inflationFactor = b.inflationFactor();
 
    DLOG("implySpread for securityId " << securityId << ":");
    DLOG("settlement date         = " << QuantLib::io::iso_date(b.bond->settlementDate()));
    DLOG("market quote            = " << cleanPrice);
    DLOG("accrueds                = " << b.bond->accruedAmount());
    DLOG("inflation factor        = " << inflationFactor);
    DLOG("price quote method adj  = " << adj);
    DLOG("effective market price  = " << cleanPrice * inflationFactor * adj);
 
    auto targetFunction = [&b, spreadQuote, cleanPrice, adj, inflationFactor](const Real& s) {
        spreadQuote->setValue(s);
        if (b.modelBuilder != nullptr)
            b.modelBuilder->recalibrate();
        Real c = b.bond->cleanPrice() / 100.0;
        TLOG("--> spread imply: trying s = " << s << " yields clean price " << c);
        return c - cleanPrice * inflationFactor * adj;
    };
 
    // edge case: bond has a zero settlement value -> skip spread imply
 
    if (QuantLib::close_enough(b.bond->cleanPrice(), 0.0)) {
        DLOG("bond has a theoretical clean price of zero (no outstanding flows as of settlement date) -> skip spread "
             "imply and continue with zero security spread.");
        return 0.0;
    }
 
    // solve for spread and return result
 
    Brent brent;
    Real s = brent.solve(targetFunction, 1E-8, 0.0, 0.001);
 
    DLOG("theoretical pricing     = " << b.bond->cleanPrice() / 100.0);
    return s;
}

Here is the caller graph for this function: