DependencyGraph Class Reference

#include <ored/marketdata/dependencygraph.hpp>

Collaboration diagram for DependencyGraph:

Classes
struct	Node

Public Types
using	Graph = boost::directed_graph< Node >
using	IndexMap = boost::property_map< Graph, boost::vertex_index_t >::type
using	Vertex = boost::graph_traits< Graph >::vertex_descriptor
using	VertexIterator = boost::graph_traits< Graph >::vertex_iterator

Public Member Functions
	DependencyGraph (const Date &asof, const QuantLib::ext::shared_ptr< TodaysMarketParameters > &params, const QuantLib::ext::shared_ptr< const CurveConfigurations > &curveConfigs, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig())
void	buildDependencyGraph (const std::string &configuration, std::map< std::string, std::string > &buildErrors)
std::map< std::string, Graph >	dependencies ()

Private Attributes
std::map< std::string, Graph >	dependencies_
const Date	asof_
const QuantLib::ext::shared_ptr< TodaysMarketParameters >	params_
const QuantLib::ext::shared_ptr< const CurveConfigurations >	curveConfigs_
const IborFallbackConfig	iborFallbackConfig_

Friends
std::ostream &	operator<< (std::ostream &o, const Node &n)

Detailed Description

Definition at line 78 of file dependencygraph.hpp.

Member Typedef Documentation

Graph

using Graph = boost::directed_graph<Node>

Definition at line 103 of file dependencygraph.hpp.

IndexMap

using IndexMap = boost::property_map<Graph, boost::vertex_index_t>::type

Definition at line 104 of file dependencygraph.hpp.

Vertex

using Vertex = boost::graph_traits<Graph>::vertex_descriptor

Definition at line 105 of file dependencygraph.hpp.

VertexIterator

using VertexIterator = boost::graph_traits<Graph>::vertex_iterator

Definition at line 106 of file dependencygraph.hpp.

Constructor & Destructor Documentation

DependencyGraph()

DependencyGraph	(	const Date &	asof,
		const QuantLib::ext::shared_ptr< TodaysMarketParameters > &	params,
		const QuantLib::ext::shared_ptr< const CurveConfigurations > &	curveConfigs,
		const IborFallbackConfig &	iborFallbackConfig = IborFallbackConfig::defaultConfig()
	)

Parameters

asof	The asof date of the T0 market instance
params	Description of the market composition
curveConfigs	Description of curve compositions
iborFallbackConfig	Ibor fallback config

Definition at line 81 of file dependencygraph.hpp.

        : asof_(asof), params_(params), curveConfigs_(curveConfigs),
          iborFallbackConfig_(iborFallbackConfig){};

Member Function Documentation

buildDependencyGraph()

void buildDependencyGraph	(	const std::string &	configuration,
		std::map< std::string, std::string > &	buildErrors
	)

Definition at line 37 of file dependencygraph.cpp.

                                                                                      {
 
    LOG("Build dependency graph for TodaysMarket configuration " << configuration);
 
    Graph& g = dependencies_[configuration];
    IndexMap index = QuantLib::ext::get(boost::vertex_index, g);
    QuantLib::ext::shared_ptr<Conventions> conventions = InstrumentConventions::instance().conventions();
 
    // add the vertices
    std::set<MarketObject> t = getMarketObjectTypes(); // from todaysmarket parameter
 
    for (auto const& o : t) {
        auto mapping = params_->mapping(o, configuration);
        for (auto const& m : mapping) {
            Vertex v = boost::add_vertex(g);
            QuantLib::ext::shared_ptr<CurveSpec> spec;
            // swap index curves do not have a spec
            if (o != MarketObject::SwapIndexCurve)
                spec = parseCurveSpec(m.second);
            // add the vertex to the dependency graph
            g[v] = {o, m.first, m.second, spec, false};
            TLOG("add vertex # " << index[v] << ": " << g[v]);
        }
    }
 
    // add the dependencies based on the required curve ids stored in the curve configs; notice that no dependencies
    // to FXSpots are stored in the configs, these are not needed because a complete FXTriangulation object is created
    // upfront that is passed to all curve builders which require it.
 
    VertexIterator v, vend, w, wend;
 
    for (std::tie(v, vend) = boost::vertices(g); v != vend; ++v) {
        if (g[*v].curveSpec) {
            for (auto const& r :
                 curveConfigs_->requiredCurveIds(g[*v].curveSpec->baseType(), g[*v].curveSpec->curveConfigID())) {
                for (auto const& cId : r.second) {
                    // avoid self reference
                    if (r.first == g[*v].curveSpec->baseType() && cId == g[*v].curveSpec->curveConfigID())
                        continue;
                    bool found = false;
                    for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                        if (*w != *v && g[*w].curveSpec && r.first == g[*w].curveSpec->baseType() &&
                            cId == g[*w].curveSpec->curveConfigID()) {
                            g.add_edge(*v, *w);
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                            found = true;
                            // it is enough to insert one dependency
                            break;
                        }
                    }
                    if (!found)
                        buildErrors[g[*v].mapping] = "did not find required curve id " + cId + " of type " +
                                                     ore::data::to_string(r.first) + " (required from " +
                                                     ore::data::to_string(g[*v]) +
                                                     ") in dependency graph for configuration " + configuration;
                }
            }
        }
    }
 
    // add additional dependencies that are not captured in the curve config dependencies
    // it is a bit unfortunate that we have to handle these exceptions here, we should rather strive to have all
    // dependencies in the curve configurations
 
    for (std::tie(v, vend) = boost::vertices(g); v != vend; ++v) {
 
        // 1 CapFloorVolatility depends on underlying index curve(s)
 
        if (g[*v].obj == MarketObject::CapFloorVol &&
            curveConfigs_->hasCapFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())) {
            std::set<string> indices;
            if(!curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->index().empty())
            indices.insert(curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->index());
            if(!curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->proxySourceIndex().empty())
            indices.insert(curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->proxySourceIndex());
            if(!curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->proxyTargetIndex().empty())
            indices.insert(curveConfigs_->capFloorVolCurveConfig(g[*v].curveSpec->curveConfigID())->proxyTargetIndex());
            for (auto const& ind : indices) {
                bool found = false;
                for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                    if (*w != *v && g[*w].obj == MarketObject::IndexCurve && g[*w].name == ind) {
                        g.add_edge(*v, *w);
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                        found = true;
                        // there should be only one dependency, in any case it is enough to insert one
                        break;
                    }
                }
                if (!found)
                    buildErrors[g[*v].mapping] = "did not find required ibor index " + ind + " (required from " +
                                                 ore::data::to_string(g[*v]) +
                                                 ") in dependency graph for configuration " + configuration;
            }
        }
 
        // 2 Correlation depends on underlying swap indices (if CMS Spread Correlations are calibrated to prices)
 
        if (g[*v].obj == MarketObject::Correlation &&
            curveConfigs_->hasCorrelationCurveConfig(g[*v].curveSpec->curveConfigID())) {
            auto config = curveConfigs_->correlationCurveConfig(g[*v].curveSpec->curveConfigID());
            if (config->correlationType() == CorrelationCurveConfig::CorrelationType::CMSSpread &&
                config->quoteType() == MarketDatum::QuoteType::PRICE) {
                bool found1 = config->index1().empty(), found2 = config->index2().empty();
                for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                    if (*w != *v) {
                        if (g[*w].name == config->index1()) {
                            g.add_edge(*v, *w);
                            found1 = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                        if (g[*w].name == config->index1()) {
                            g.add_edge(*v, *w);
                            found2 = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                    }
                    // there should be only one dependency, in any case it is enough to insert one
                    if (found1 && found2)
                        break;
                }
                if (!found1)
                    buildErrors[g[*v].mapping] = "did not find required swap index " + config->index1() +
                                                 " (required from " + ore::data::to_string(g[*v]) +
                                                 ") in dependency graph for configuration " + configuration;
                if (!found2)
                    buildErrors[g[*v].mapping] = "did not find required swap index " + config->index2() +
                                                 " (required from " + ore::data::to_string(g[*v]) +
                                                 ") in dependency graph for configuration " + configuration;
            }
        }
 
        // 3 SwaptionVolatility depends on underlying swap indices
 
        if (g[*v].obj == MarketObject::SwaptionVol &&
            curveConfigs_->hasSwaptionVolCurveConfig(g[*v].curveSpec->curveConfigID())) {
            auto config = curveConfigs_->swaptionVolCurveConfig(g[*v].curveSpec->curveConfigID());
            std::set<std::string> indexBases;
            if (!config->shortSwapIndexBase().empty())
                indexBases.insert(config->shortSwapIndexBase());
            if (!config->swapIndexBase().empty())
                indexBases.insert(config->swapIndexBase());
            if (!config->proxySourceShortSwapIndexBase().empty())
                indexBases.insert(config->proxySourceShortSwapIndexBase());
            if (!config->proxySourceSwapIndexBase().empty())
                indexBases.insert(config->proxySourceSwapIndexBase());
            if (!config->proxyTargetShortSwapIndexBase().empty())
                indexBases.insert(config->proxyTargetShortSwapIndexBase());
            if (!config->proxyTargetSwapIndexBase().empty())
                indexBases.insert(config->proxyTargetSwapIndexBase());
            for (auto const& indexBase : indexBases) {
                bool found = false;
                for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                    if (*w != *v) {
                        if (g[*w].name == indexBase) {
                            g.add_edge(*v, *w);
                            found = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                    }
                    // there should be only one dependency, in any case it is enough to insert one
                    if (found)
                        break;
                }
                if (!found)
                    buildErrors[g[*v].mapping] = "did not find required swap index " + indexBase + " (required from " +
                                                 ore::data::to_string(g[*v]) +
                                                 ") in dependency graph for configuration " + configuration;
            }
        }
 
        // 4 Swap Indices depend on underlying ibor and discount indices
 
        if (g[*v].obj == MarketObject::SwapIndexCurve) {
            bool foundIbor = false, foundDiscount = false;
            std::string swapIndex = g[*v].name;
            auto swapCon = QuantLib::ext::dynamic_pointer_cast<data::SwapIndexConvention>(conventions->get(swapIndex));
            QL_REQUIRE(swapCon, "Did not find SwapIndexConvention for " << swapIndex);
            auto con = QuantLib::ext::dynamic_pointer_cast<data::IRSwapConvention>(conventions->get(swapCon->conventions()));
            auto conOisComp =
                QuantLib::ext::dynamic_pointer_cast<data::OisConvention>(conventions->get(swapCon->conventions()));
            auto conOisAvg =
                QuantLib::ext::dynamic_pointer_cast<data::AverageOisConvention>(conventions->get(swapCon->conventions()));
            std::string indexName;
            if(con)
                indexName = con->indexName();
            else if(conOisComp)
                indexName = conOisComp->indexName();
            else if(conOisAvg)
                indexName = conOisAvg->indexName();
            else {
                QL_FAIL("DependencyGraph: internal errors, expected IRSwapConvention, OisConvention, "
                        "AverageOisConvention for '"
                        << swapCon->conventions() << "' from conventions for swap index '" << swapIndex << "'");
            }
            std::string discountIndex = g[*v].mapping;
            if (isGenericIborIndex(indexName))
                foundIbor = true;
            for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                if (*w != *v) {
                    if (g[*w].obj == MarketObject::IndexCurve || g[*w].obj == MarketObject::YieldCurve) {
                        if (g[*w].name == discountIndex) {
                            g.add_edge(*v, *w);
                            foundDiscount = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                        if (g[*w].name == indexName) {
                            g.add_edge(*v, *w);
                            foundIbor = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                    }
                }
                // there should be only one dependency, in any case it is enough to insert one
                if (foundDiscount && foundIbor)
                    break;
            }
            if (!foundIbor)
                buildErrors[g[*v].mapping] = "did not find required ibor/ois index " + indexName + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
            if (!foundDiscount)
                buildErrors[g[*v].mapping] = "did not find required discount index " + discountIndex +
                                             " (required from " + ore::data::to_string(g[*v]) +
                                             ") in dependency graph for configuration " + configuration;
        }
 
        if (g[*v].obj == MarketObject::YieldCurve || g[*v].obj == MarketObject::DiscountCurve) {
            if (curveConfigs_->hasYieldCurveConfig(g[*v].curveSpec->curveConfigID())) {
                QuantLib::ext::shared_ptr<YieldCurveConfig> config =
                    curveConfigs_->yieldCurveConfig(g[*v].curveSpec->curveConfigID());
                vector<QuantLib::ext::shared_ptr<YieldCurveSegment>> segments = config->curveSegments();
                for (auto s : segments) {
                    if (auto ccSegment = QuantLib::ext::dynamic_pointer_cast<CrossCcyYieldCurveSegment>(s)) {
                        if (ccSegment->foreignDiscountCurveID() == "") {
                            // find the foreign ccy
                            std::string ccy = config->currency();
                            std::string spot = ccSegment->spotRateID();
                            std::string foreignCcy;
                            auto spotDatum = parseMarketDatum(Date(), spot, Real());
                            if (auto fxq = QuantLib::ext::dynamic_pointer_cast<FXSpotQuote>(spotDatum))
                                foreignCcy = ccy == fxq->unitCcy() ? fxq->ccy() : fxq->unitCcy();
 
                            for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                                if (*w != *v) {
                                    if (g[*w].obj == MarketObject::DiscountCurve && g[*w].name == foreignCcy) {
                                        g.add_edge(*v, *w);
                                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #"
                                                                      << index[*w] << " " << g[*w]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
 
        // 5 Equity Vol depends on spot, discount, div
 
        if (g[*v].obj == MarketObject::EquityVol) {
            bool foundDiscount = false, foundEqCurve = false;
            std::string eqName = g[*v].name;
            auto eqVolSpec = QuantLib::ext::dynamic_pointer_cast<EquityVolatilityCurveSpec>(g[*v].curveSpec);
            QL_REQUIRE(eqVolSpec, "could not cast to EquityVolatilityCurveSpec");
            std::string ccy = eqVolSpec->ccy();
            for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                if (*w != *v) {
                    if (g[*w].obj == MarketObject::DiscountCurve && g[*w].name == ccy) {
                        g.add_edge(*v, *w);
                        foundDiscount = true;
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                    }
                    if (g[*w].obj == MarketObject::EquityCurve && g[*w].name == eqName) {
                        g.add_edge(*v, *w);
                        foundEqCurve = true;
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                    }
                }
                // there should be only one dependency, in any case it is enough to insert one
                if (foundDiscount && foundEqCurve)
                    break;
            }
            if (!foundDiscount)
                buildErrors[g[*v].mapping] = "did not find required discount curve " + ccy + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
            if (!foundEqCurve)
                buildErrors[g[*v].mapping] = "did not find required equity curve " + eqName + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
        }
 
        // 6 Commodity Vol depends on price, discount
 
        if (g[*v].obj == MarketObject::CommodityVolatility) {
            bool foundDiscount = false, foundCommCurve = false;
            std::string commName = g[*v].name;
            auto commVolSpec = QuantLib::ext::dynamic_pointer_cast<CommodityVolatilityCurveSpec>(g[*v].curveSpec);
            QL_REQUIRE(commVolSpec, "could not cast to CommodityVolatilityCurveSpec");
            std::string ccy = commVolSpec->currency();
            for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                if (*w != *v) {
                    if (g[*w].obj == MarketObject::DiscountCurve && g[*w].name == ccy) {
                        g.add_edge(*v, *w);
                        foundDiscount = true;
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                    }
                    if (g[*w].obj == MarketObject::CommodityCurve && g[*w].name == commName) {
                        g.add_edge(*v, *w);
                        foundCommCurve = true;
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                    }
                }
                // there should be only one dependency, in any case it is enough to insert one
                if (foundDiscount && foundCommCurve)
                    break;
            }
            if (!foundDiscount)
                buildErrors[g[*v].mapping] = "did not find required discount curve " + ccy + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
            if (!foundCommCurve)
                buildErrors[g[*v].mapping] = "did not find required commodity curve " + commName + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
        }
 
        // 7 Ibor fallback handling: an ibor index to replace depends on the fallback rfr index
 
        if (g[*v].obj == MarketObject::IndexCurve) {
            if (iborFallbackConfig_.isIndexReplaced(g[*v].name, asof_)) {
                bool foundRfrIndex = false;
                for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                    if (*w != *v) {
                        if (g[*w].obj == MarketObject::IndexCurve &&
                            g[*w].name == iborFallbackConfig_.fallbackData(g[*v].name).rfrIndex) {
                            g.add_edge(*v, *w);
                            foundRfrIndex = true;
                            TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                          << g[*w]);
                        }
                    }
                    if (foundRfrIndex)
                        break;
                }
                if (!foundRfrIndex)
                    buildErrors[g[*v].mapping] = "did not find required rfr index '" +
                                                 iborFallbackConfig_.fallbackData(g[*v].name).rfrIndex +
                                                 "' for replaced ibor index '" + g[*v].name +
                                                 "', is the rfr index configured in todays market parameters?";
            }
        }
 
        // 8 FX curve depends on discount
 
        if (g[*v].obj == MarketObject::FXSpot) {
            bool foundDiscount1 = false, foundDiscount2 = false;
            std::string fxName = g[*v].name;
            auto fxSpec = QuantLib::ext::dynamic_pointer_cast<FXSpotSpec>(g[*v].curveSpec);
            QL_REQUIRE(fxSpec, "could not cast to FXSpotSpec");
            std::string ccy1 = fxSpec->unitCcy();
            std::string ccy2 = fxSpec->ccy();
            for (std::tie(w, wend) = boost::vertices(g); w != wend; ++w) {
                if (*w != *v) {
                    if (g[*w].obj == MarketObject::DiscountCurve && (g[*w].name == ccy1 || g[*w].name == ccy2)) {
                        g.add_edge(*v, *w);
                        if (g[*w].name == ccy1)
                            foundDiscount1 = true;
                        if (g[*w].name == ccy2)
                            foundDiscount2 = true;
                        TLOG("add edge from vertex #" << index[*v] << " " << g[*v] << " to #" << index[*w] << " "
                                                      << g[*w]);
                    }
                }
                // there should be only one dependency, in any case it is enough to insert one
                if (foundDiscount1 && foundDiscount2)
                    break;
            }
            if (!foundDiscount1)
                buildErrors[g[*v].mapping] = "did not find required discount curve " + ccy1 + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
            if (!foundDiscount2)
                buildErrors[g[*v].mapping] = "did not find required discount curve " + ccy2 + " (required from " +
                                             ore::data::to_string(g[*v]) + ") in dependency graph for configuration " +
                                             configuration;
        }
    }
 
    DLOG("Dependency graph built with " << boost::num_vertices(g) << " vertices, " << boost::num_edges(g) << " edges.");
 
} // TodaysMarket::buildDependencyGraph

Here is the call graph for this function:

Here is the caller graph for this function:

dependencies()

std::map< std::string, Graph > dependencies

(

)

Definition at line 112 of file dependencygraph.hpp.

{ return dependencies_; }

Here is the caller graph for this function:

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  o, const Node &  n  )

friend

Definition at line 949 of file todaysmarket.cpp.

                                                                    {
    return o << n.obj << "(" << n.name << "," << n.mapping << ")";
}

Member Data Documentation

dependencies_

std::map<std::string, Graph> dependencies_

private

Definition at line 118 of file dependencygraph.hpp.

asof_

const Date asof_

private

Definition at line 120 of file dependencygraph.hpp.

params_

const QuantLib::ext::shared_ptr<TodaysMarketParameters> params_

private

Definition at line 121 of file dependencygraph.hpp.

curveConfigs_

const QuantLib::ext::shared_ptr<const CurveConfigurations> curveConfigs_

private

Definition at line 122 of file dependencygraph.hpp.

iborFallbackConfig_

const IborFallbackConfig iborFallbackConfig_

private

Definition at line 123 of file dependencygraph.hpp.