Class that wraps a sensitivity stream and decompose default, equity and commodity risk records given weights. More...

#include <orea/engine/decomposedsensitivitystream.hpp>

Inheritance diagram for DecomposedSensitivityStream:

Collaboration diagram for DecomposedSensitivityStream:

Classes
struct	IndexDecompositionResult

Public Member Functions
	DecomposedSensitivityStream (const QuantLib::ext::shared_ptr< SensitivityStream > &ss, const std::string &baseCurrency, std::map< std::string, std::map< std::string, double > > defaultRiskDecompositionWeights={}, const std::set< std::string > &eqComDecompositionTradeIds={}, const std::map< std::string, std::map< std::string, double > > &currencyHedgedIndexQuantities={}, const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &refDataManager=nullptr, const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &curveConfigs=nullptr, const QuantLib::ext::shared_ptr< SensitivityScenarioData > &scenarioData=nullptr, const QuantLib::ext::shared_ptr< ore::data::Market > &todaysMarket=nullptr)

SensitivityRecord	next () override
	Returns the next SensitivityRecord in the stream after filtering. More...

void	reset () override
	Resets the stream so that SensitivityRecord objects can be streamed again. More...

Public Member Functions inherited from SensitivityStream
virtual	~SensitivityStream ()
	Destructor. More...

virtual SensitivityRecord	next ()=0
	Returns the next SensitivityRecord in the stream. More...

virtual void	reset ()=0
	Resets the stream so that SensitivityRecord objects can be streamed again. More...

Private Member Functions
std::map< std::string, double >	constituentSpotRiskFromDecomposition (const double spotDelta, const std::map< std::string, double > &indexWeights) const
	Decompose a equity/commodity spot sensitivity into the constituent spot sensistivities. More...

std::map< std::string, double >	fxRiskFromDecomposition (const std::map< std::string, double > &spotRisk, const std::map< std::string, std::vector< std::string > > &constituentCurrencies, const std::map< std::string, double > &fxSpotShiftSize, const double eqShiftSize) const
	Compute the resulting fx risks from a given equity/commodity decomposition. More...

double	fxRiskShiftSize (const std::string ccy) const
	Return the sensi shift size for the shifting the ccy-baseCurrency spot quote. More...

std::map< std::string, double >	fxRiskShiftSizes (const std::map< std::string, std::vector< std::string > > &constituentCurrencies) const
	Returns the shift sizes for all currencies in the map. More...

double	assetSpotShiftSize (const std::string name, const ore::data::CurveSpec::CurveType curveType) const
	Return the asset spot shift size. More...

double	equitySpotShiftSize (const std::string name) const

double	commoditySpotShiftSize (const std::string name) const

std::map< std::string, std::vector< std::string > >	getConstituentCurrencies (const std::map< std::string, double > &constituents, const std::string &indexCurrency, const ore::data::CurveSpec::CurveType curveType) const

std::vector< SensitivityRecord >	decompose (const SensitivityRecord &record) const
	Decompose the record and add it to the internal storage;. More...

std::vector< SensitivityRecord >	decomposeSurvivalProbability (const SensitivityRecord &record) const

std::vector< SensitivityRecord >	decomposeCurrencyHedgedIndexRisk (const SensitivityRecord &record) const

IndexDecompositionResult	indexDecomposition (double delta, const std::string &indexName, const ore::data::CurveSpec::CurveType curveType) const

std::vector< SensitivityRecord >	sensitivityRecords (const std::map< std::string, double > &eqDeltas, const std::map< std::string, double > &fxDeltas, const std::string indexCurrency, const SensitivityRecord &orginialRecord) const

std::string	curveCurrency (const std::string &name, ore::data::CurveSpec::CurveType curveType) const

Private Attributes
std::vector< SensitivityRecord >	decomposedRecords_

std::vector< SensitivityRecord >::iterator	itCurrent_

QuantLib::ext::shared_ptr< SensitivityStream >	ss_
	The underlying sensitivity stream that has been wrapped. More...

std::string	baseCurrency_

std::map< std::string, std::map< std::string, double > >	defaultRiskDecompositionWeights_
	map of trade ids to the basket consituents with their resp. weights More...

std::set< std::string >	eqComDecompositionTradeIds_
	list of trade id, for which a equity index decomposition should be applied More...

std::map< std::string, std::map< std::string, double > >	currencyHedgedIndexQuantities_
	list of trade id, for which a commodity index decomposition should be applied More...

QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager >	refDataManager_
	refDataManager holding the equity and commodity index decomposition weights More...

QuantLib::ext::shared_ptr< ore::data::CurveConfigurations >	curveConfigs_

QuantLib::ext::shared_ptr< SensitivityScenarioData >	ssd_

QuantLib::ext::shared_ptr< ore::data::Market >	todaysMarket_

bool	decompose_

Detailed Description

Class that wraps a sensitivity stream and decompose default, equity and commodity risk records given weights.

Definition at line 38 of file decomposedsensitivitystream.hpp.

Constructor & Destructor Documentation

◆ DecomposedSensitivityStream()

DecomposedSensitivityStream	(	const QuantLib::ext::shared_ptr< SensitivityStream > &	ss,
		const std::string &	baseCurrency,
		std::map< std::string, std::map< std::string, double > >	defaultRiskDecompositionWeights = `{}`,
		const std::set< std::string > &	eqComDecompositionTradeIds = `{}`,
		const std::map< std::string, std::map< std::string, double > > &	currencyHedgedIndexQuantities = `{}`,
		const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &	refDataManager = `nullptr`,
		const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &	curveConfigs = `nullptr`,
		const QuantLib::ext::shared_ptr< SensitivityScenarioData > &	scenarioData = `nullptr`,
		const QuantLib::ext::shared_ptr< ore::data::Market > &	todaysMarket = `nullptr`
	)

Constructor providing the weights for the credit index decomposition and the ids and reference data used for

Definition at line 30 of file decomposedsensitivitystream.cpp.

    : ss_(ss), baseCurrency_(baseCurrency), defaultRiskDecompositionWeights_(defaultRiskDecompositionWeights),
      eqComDecompositionTradeIds_(eqComDecompositionTradeIds),
      currencyHedgedIndexQuantities_(currencyHedgedIndexQuantities), refDataManager_(refDataManager),
      curveConfigs_(curveConfigs), ssd_(scenarioData), todaysMarket_(todaysMarket) {
    reset();
    decompose_ = !defaultRiskDecompositionWeights_.empty() || !eqComDecompositionTradeIds_.empty();
}

Here is the call graph for this function:

Member Function Documentation

◆ next()

SensitivityRecord next ( )

overridevirtual

Returns the next SensitivityRecord in the stream after filtering.

Implements SensitivityStream.

Definition at line 48 of file decomposedsensitivitystream.cpp.

                                                    {
    if (!decompose_)
        return ss_->next();
    // No decomposed records left, so continue to the next record
    if (itCurrent_ == decomposedRecords_.end()) {
        decomposedRecords_ = decompose(ss_->next());
        itCurrent_ = decomposedRecords_.begin();
    }
    return *(itCurrent_++);
}

Here is the call graph for this function:

◆ reset()

void reset ( )

overridevirtual

Resets the stream so that SensitivityRecord objects can be streamed again.

Implements SensitivityStream.

Definition at line 319 of file decomposedsensitivitystream.cpp.

                                        {
    ss_->reset();
    decomposedRecords_.clear();
    itCurrent_ = decomposedRecords_.begin();
}

Here is the caller graph for this function:

◆ constituentSpotRiskFromDecomposition()

std::map< std::string, double > constituentSpotRiskFromDecomposition	(	const double	spotDelta,
		const std::map< std::string, double > &	indexWeights
	)		const

private

Decompose a equity/commodity spot sensitivity into the constituent spot sensistivities.

Decompose.

Definition at line 133 of file decomposedsensitivitystream.cpp.

                                                                                 {
    std::map<std::string, double> results;
    for (const auto& [constituent, weight] : indexWeights) {
        results[constituent] = weight * spotDelta;
    }
    return results;
}

Here is the caller graph for this function:

◆ fxRiskFromDecomposition()

std::map< std::string, double > fxRiskFromDecomposition	(	const std::map< std::string, double > &	spotRisk,
		const std::map< std::string, std::vector< std::string > > &	constituentCurrencies,
		const std::map< std::string, double > &	fxSpotShiftSize,
		const double	eqShiftSize
	)		const

private

Compute the resulting fx risks from a given equity/commodity decomposition.

Definition at line 142 of file decomposedsensitivitystream.cpp.

                                                                                      {
    std::map<std::string, double> results;
    for (const auto& [currency, constituents] : constituentCurrencies) {
        if (currency != baseCurrency_) {
            QL_REQUIRE(fxSpotShiftSize.count(currency) == 1, "Can not find fxSpotShiftSize for currency " << currency);
            for (const auto& constituent : constituents) {
                QL_REQUIRE(spotRisk.count(constituent) == 1, "Can not find spotDelta for " << constituent);
                results[currency] += spotRisk.at(constituent) * fxSpotShiftSize.at(currency) / eqShiftSize;
            }
        }
    }
    return results;
}

Here is the caller graph for this function:

◆ fxRiskShiftSize()

double fxRiskShiftSize ( const std::string ccy ) const

private

Return the sensi shift size for the shifting the ccy-baseCurrency spot quote.

Definition at line 159 of file decomposedsensitivitystream.cpp.

                                                                             {
    auto fxpair = ccy + baseCurrency_;
    auto fxShiftSizeIt = ssd_->fxShiftData().find(fxpair);
    QL_REQUIRE(fxShiftSizeIt != ssd_->fxShiftData().end(), "Couldn't find shiftsize for " << fxpair);
    QL_REQUIRE(fxShiftSizeIt->second.shiftType == ore::analytics::ShiftType::Relative,
               "Requires a relative fxSpot shift for index decomposition");
    return fxShiftSizeIt->second.shiftSize;
}

Here is the caller graph for this function:

◆ fxRiskShiftSizes()

std::map< std::string, double > fxRiskShiftSizes ( const std::map< std::string, std::vector< std::string > > & constituentCurrencies ) const

private

Returns the shift sizes for all currencies in the map.

Definition at line 169 of file decomposedsensitivitystream.cpp.

                                                                                                             {
    std::map<std::string, double> results;
    for (const auto& [ccy,_] : currencies) {
        if (ccy != baseCurrency_) {
            double shiftSize = fxRiskShiftSize(ccy);
            results[ccy] = shiftSize;
        }
    }
    return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ assetSpotShiftSize()

double assetSpotShiftSize	(	const std::string	name,
		const ore::data::CurveSpec::CurveType	curveType
	)		const

private

Return the asset spot shift size.

Definition at line 188 of file decomposedsensitivitystream.cpp.

                                                                                                        {
    if (curveType == ore::data::CurveSpec::CurveType::Equity) {
        return equitySpotShiftSize(indexName);
    } else if (curveType == ore::data::CurveSpec::CurveType::Commodity) {
        return commoditySpotShiftSize(indexName);
    } else {
        QL_FAIL("unsupported curveType, got  "
                << curveType << ". Only Equity and Commodity curves are supported for decomposition.");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ equitySpotShiftSize()

double equitySpotShiftSize ( const std::string name ) const

private

Definition at line 180 of file decomposedsensitivitystream.cpp.

                                                                                  {
    auto eqShiftSizeIt = ssd_->equityShiftData().find(name);
    QL_REQUIRE(eqShiftSizeIt != ssd_->equityShiftData().end(), "Couldn't find a equity shift size for " << name);
    QL_REQUIRE(eqShiftSizeIt->second.shiftType == ore::analytics::ShiftType::Relative,
               "Requires a relative eqSpot shift for index decomposition");
    return eqShiftSizeIt->second.shiftSize;
}

Here is the caller graph for this function:

◆ commoditySpotShiftSize()

double commoditySpotShiftSize ( const std::string name ) const

private

Definition at line 200 of file decomposedsensitivitystream.cpp.

                                                                                     {
    auto commShiftSizeIt = ssd_->commodityCurveShiftData().find(name);
    if (commShiftSizeIt != ssd_->commodityCurveShiftData().end()) {
        QL_REQUIRE(commShiftSizeIt->second->shiftType == ore::analytics::ShiftType::Relative,
                   "Requires a relative eqSpot shift for index decomposition");
        return commShiftSizeIt->second->shiftSize;
    } else {
        LOG("Could not find a commodity shift size for commodity index "
            << name << ". Try to find a equity spot shift size as fallback")
        return equitySpotShiftSize(name);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getConstituentCurrencies()

std::map< std::string, std::vector< std::string > > getConstituentCurrencies	(	const std::map< std::string, double > &	constituents,
		const std::string &	indexCurrency,
		const ore::data::CurveSpec::CurveType	curveType
	)		const

private

Definition at line 214 of file decomposedsensitivitystream.cpp.

                                                                                                       {
    std::map<std::string, std::vector<std::string>> results;
    for (const auto& [constituent, _] : constituents) {
        auto ccy = curveCurrency(constituent, curveType);
        if (ccy.empty()) {
            ccy = indexCurrency;
            StructuredAnalyticsErrorMessage("CRIF Generation", "Equity index decomposition",
                                            "Cannot find currency for equity " + constituent +
                                                " from curve configs, fallback to use index currency (" +
                                                indexCurrency + ")")
                .log();
        }
        if (ccy != baseCurrency_) {
            results[ccy].push_back(constituent);
        }
        
    }
    return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose()

std::vector< SensitivityRecord > decompose ( const SensitivityRecord & record ) const

private

Decompose the record and add it to the internal storage;.

Definition at line 59 of file decomposedsensitivitystream.cpp.

                                                                                                         {
    std::vector<SensitivityRecord> results;
 
    bool tradeMarkedForDecompositionDefaultRisk =
        defaultRiskDecompositionWeights_.find(record.tradeId) != defaultRiskDecompositionWeights_.end();
    bool tradeMarkedForDecomposition =
        eqComDecompositionTradeIds_.find(record.tradeId) != eqComDecompositionTradeIds_.end();
    bool isNotCrossGamma = record.isCrossGamma() == false;
    bool isSurvivalProbSensi = record.key_1.keytype == RiskFactorKey::KeyType::SurvivalProbability;
    bool isEquitySpotSensi = record.key_1.keytype == RiskFactorKey::KeyType::EquitySpot;
    bool isCommoditySpotSensi = record.key_1.keytype == RiskFactorKey::KeyType::CommodityCurve;
 
    bool decomposeEquitySpot = tradeMarkedForDecomposition && isEquitySpotSensi && refDataManager_ != nullptr &&
                               refDataManager_->hasData("EquityIndex", record.key_1.name);
    bool decomposeCurrencyHedgedSpot = tradeMarkedForDecomposition && isEquitySpotSensi && refDataManager_ != nullptr &&
                                       refDataManager_->hasData("CurrencyHedgedEquityIndex", record.key_1.name);
    bool decomposeCommoditySpot = tradeMarkedForDecomposition && (isCommoditySpotSensi || isEquitySpotSensi) &&
                                  refDataManager_ != nullptr &&
                                  refDataManager_->hasData("CommodityIndex", record.key_1.name);
 
    try {
        if (tradeMarkedForDecompositionDefaultRisk && isSurvivalProbSensi && isNotCrossGamma) {
            return decomposeSurvivalProbability(record);
        } else if (decomposeEquitySpot && isNotCrossGamma) {
            auto decompResults =
                indexDecomposition(record.delta, record.key_1.name, ore::data::CurveSpec::CurveType::Equity);
            return sensitivityRecords(decompResults.spotRisk, decompResults.fxRisk, decompResults.indexCurrency,
                                      record);
        } else if (decomposeCurrencyHedgedSpot && isNotCrossGamma) {
            return decomposeCurrencyHedgedIndexRisk(record);
        } else if (decomposeCommoditySpot && isNotCrossGamma) {
            auto decompResults =
                indexDecomposition(record.delta, record.key_1.name, ore::data::CurveSpec::CurveType::Commodity);
            return sensitivityRecords(decompResults.spotRisk, decompResults.fxRisk, decompResults.indexCurrency,
                                      record);
        } else if (tradeMarkedForDecomposition && (isCommoditySpotSensi || isEquitySpotSensi) && isNotCrossGamma) {
            auto subFields = std::map<std::string, std::string>({{"tradeId", record.tradeId}});
            StructuredAnalyticsErrorMessage(
                "Sensitivity Decomposition", "Index decomposition failed",
                "Cannot decompose equity index delta (" + record.key_1.name +
                    ") for trade: no reference data found. Continuing without decomposition.",
                subFields)
                .log();
        }
    } catch (const std::exception& e) {
        auto subFields = std::map<std::string, std::string>({{"tradeId", record.tradeId}});
        StructuredAnalyticsErrorMessage(
            "Sensitivity Decomposition", "Index decomposition failed",
            "Cannot decompose equity index delta (" + record.key_1.name + ") for trade:" + e.what(), subFields)
            .log();
    } catch (...) {
        auto subFields = std::map<std::string, std::string>({{"tradeId", record.tradeId}});
        StructuredAnalyticsErrorMessage(
            "Sensitivity Decomposition", "Index decomposition failed",
            "Cannot decompose equity index delta (" + record.key_1.name + ") for trade: unkown error", subFields)
            .log();
    }
    return {record};
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decomposeSurvivalProbability()

std::vector< SensitivityRecord > decomposeSurvivalProbability ( const SensitivityRecord & record ) const

private

Definition at line 120 of file decomposedsensitivitystream.cpp.

                                                                                               {
    std::vector<SensitivityRecord> results;
    auto decompRecord = record;
    for (const auto& [constituent, weight] : defaultRiskDecompositionWeights_.at(record.tradeId)) {
        decompRecord.key_1 = RiskFactorKey(record.key_1.keytype, constituent, record.key_1.index);
        decompRecord.delta = record.delta * weight;
        decompRecord.gamma = record.gamma * weight;
        results.push_back(decompRecord);
    }
    return results;
}

Here is the caller graph for this function:

◆ decomposeCurrencyHedgedIndexRisk()

std::vector< SensitivityRecord > decomposeCurrencyHedgedIndexRisk ( const SensitivityRecord & record ) const

private

Definition at line 262 of file decomposedsensitivitystream.cpp.

                                                                                               {
 
    auto indexName = sr.key_1.name;
    auto indexCurrency = curveCurrency(indexName, ore::data::CurveSpec::CurveType::Equity);
 
    QuantLib::ext::shared_ptr<ore::data::CurrencyHedgedEquityIndexDecomposition> decomposeCurrencyHedgedIndexHelper;
    decomposeCurrencyHedgedIndexHelper =
        loadCurrencyHedgedIndexDecomposition(indexName, refDataManager_, curveConfigs_);
    if (decomposeCurrencyHedgedIndexHelper != nullptr) {
        QL_REQUIRE(currencyHedgedIndexQuantities_.count(sr.tradeId) > 0,
                   "CurrencyHedgedIndexDecomposition failed, there is no index quantity for trade "
                       << sr.tradeId << " and equity index EQ-" << indexName);
        QL_REQUIRE(currencyHedgedIndexQuantities_.at(sr.tradeId).count("EQ-" + indexName) > 0,
                   "CurrencyHedgedIndexDecomposition failed, there is no index quantity for trade "
                       << sr.tradeId << " and equity index EQ-" << indexName);
        QL_REQUIRE(todaysMarket_ != nullptr,
                   "CurrencyHedgedIndexDecomposition failed, there is no market given quantity for trade "
                       << sr.tradeId);
 
        Date today = QuantLib::Settings::instance().evaluationDate();
 
        auto quantity = currencyHedgedIndexQuantities_.at(sr.tradeId).find("EQ-" + indexName)->second;
 
        QL_REQUIRE(quantity != QuantLib::Null<double>(),
                   "CurrencyHedgedIndexDecomposition failed, index quantity cannot be NULL.");
 
        double assetSensiShift = assetSpotShiftSize(indexName, ore::data::CurveSpec::CurveType::Equity);
 
        double hedgedExposure = sr.delta / assetSensiShift;
 
        double unhedgedExposure =
            decomposeCurrencyHedgedIndexHelper->unhedgedSpotExposure(hedgedExposure, quantity, today, todaysMarket_);
 
        double unhedgedDelta = unhedgedExposure * assetSensiShift;
 
        auto decompResults =
            indexDecomposition(unhedgedDelta, decomposeCurrencyHedgedIndexHelper->underlyingIndexName(),
                               ore::data::CurveSpec::CurveType::Equity);
 
        // Correct FX Delta from FxForwards
        for (const auto& [ccy, fxRisk] :
             decomposeCurrencyHedgedIndexHelper->fxSpotRiskFromForwards(quantity, today, todaysMarket_, 1.0)) {
            decompResults.fxRisk[ccy] = decompResults.fxRisk[ccy] - fxRisk * fxRiskShiftSize(ccy);
        }
        
        return sensitivityRecords(decompResults.spotRisk, decompResults.fxRisk, indexCurrency, sr);
    } else {
        auto subFields = std::map<std::string, std::string>({{"tradeId", sr.tradeId}});
        StructuredAnalyticsErrorMessage("CRIF Generation", "Equity index decomposition failed",
                                        "Cannot decompose equity index delta (" + indexName +
                                            ") for trade: no reference data found. Continuing without decomposition.",
                                        subFields)
            .log();
        return {sr};
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ indexDecomposition()

DecomposedSensitivityStream::IndexDecompositionResult indexDecomposition	(	double	delta,
		const std::string &	indexName,
		const ore::data::CurveSpec::CurveType	curveType
	)		const

private

Definition at line 237 of file decomposedsensitivitystream.cpp.

                                                                                                 {
    IndexDecompositionResult result;
    std::string refDataType = curveType == ore::data::CurveSpec::CurveType::Equity ? "EquityIndex" : "CommodityIndex";
 
    QL_REQUIRE(refDataManager_->hasData(refDataType, indexName),
               "Cannot decompose equity index delta ("
                   << indexName << ") for trade: no reference data found. Continuing without decomposition.");
 
    auto refDatum = refDataManager_->getData(refDataType, indexName);
    auto indexRefDatum = QuantLib::ext::dynamic_pointer_cast<ore::data::IndexReferenceDatum>(refDatum);
    std::string indexCurrency = curveCurrency(indexName, curveType);
    std::map<string, double> indexWeights = indexRefDatum->underlyings();
    auto spotRisk = constituentSpotRiskFromDecomposition(delta, indexWeights);
    auto currencies = getConstituentCurrencies(spotRisk, indexCurrency, curveType);
    auto fxShifts = fxRiskShiftSizes(currencies);
    double spotShift = assetSpotShiftSize(indexName, curveType);    
    auto fxRisk = fxRiskFromDecomposition(spotRisk, currencies, fxShifts, spotShift);
    result.spotRisk = spotRisk;
    result.fxRisk = fxRisk;
    result.indexCurrency = indexCurrency;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sensitivityRecords()

std::vector< SensitivityRecord > sensitivityRecords	(	const std::map< std::string, double > &	eqDeltas,
		const std::map< std::string, double > &	fxDeltas,
		const std::string	indexCurrency,
		const SensitivityRecord &	orginialRecord
	)		const

private

Definition at line 326 of file decomposedsensitivitystream.cpp.

                                                                                                                  {
    std::vector<SensitivityRecord> records;
    for (auto [underlying, delta] : eqDeltas) {
        RiskFactorKey underlyingKey(sr.key_1.keytype, underlying, sr.key_1.index);
        records.push_back(SensitivityRecord(sr.tradeId, sr.isPar, underlyingKey, sr.desc_1, sr.shift_1, RiskFactorKey(),
                                            "", sr.shift_2, sr.currency, sr.baseNpv, delta, 0.0));
    }
    // Add aggregated FX Deltas
    for (auto [ccy, delta] : fxDeltas) {
        if (ccy != indexCurrency && ccy != baseCurrency_) {
            RiskFactorKey underlyingKey(RiskFactorKey::KeyType::FXSpot, ccy + baseCurrency_, 0);
            records.push_back(SensitivityRecord(sr.tradeId, sr.isPar, underlyingKey, sr.desc_1, sr.shift_1,
                                                RiskFactorKey(), "", sr.shift_2, sr.currency, sr.baseNpv, delta, 0.0));
        }
    }
    return records;
}

Here is the caller graph for this function:

◆ curveCurrency()

std::string curveCurrency	(	const std::string &	name,
		ore::data::CurveSpec::CurveType	curveType
	)		const

private

Definition at line 346 of file decomposedsensitivitystream.cpp.

                                                                                                  {
    std::string curveCurrency;
    if (curveConfigs_->has(curveType, name)) {
        curveCurrency = curveType == ore::data::CurveSpec::CurveType::Equity
                            ? curveConfigs_->equityCurveConfig(name)->currency()
                            : curveConfigs_->commodityCurveConfig(name)->currency();
    } else if (curveConfigs_->hasEquityCurveConfig(name)) {
        // if we use a equity curve as proxy  fall back to lookup the currency from the proxy config
        curveCurrency = curveConfigs_->equityCurveConfig(name)->currency();
    }
    return curveCurrency;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ decomposedRecords_

std::vector<SensitivityRecord> decomposedRecords_

private

Definition at line 105 of file decomposedsensitivitystream.hpp.

◆ itCurrent_

std::vector<SensitivityRecord>::iterator itCurrent_

private

Definition at line 106 of file decomposedsensitivitystream.hpp.

◆ ss_

QuantLib::ext::shared_ptr<SensitivityStream> ss_

private

The underlying sensitivity stream that has been wrapped.

Definition at line 109 of file decomposedsensitivitystream.hpp.

◆ baseCurrency_

std::string baseCurrency_

private

Definition at line 110 of file decomposedsensitivitystream.hpp.

◆ defaultRiskDecompositionWeights_

std::map<std::string, std::map<std::string, double> > defaultRiskDecompositionWeights_

private

map of trade ids to the basket consituents with their resp. weights

Definition at line 112 of file decomposedsensitivitystream.hpp.

◆ eqComDecompositionTradeIds_

std::set<std::string> eqComDecompositionTradeIds_

private

list of trade id, for which a equity index decomposition should be applied

Definition at line 114 of file decomposedsensitivitystream.hpp.

◆ currencyHedgedIndexQuantities_

std::map<std::string, std::map<std::string, double> > currencyHedgedIndexQuantities_

private

list of trade id, for which a commodity index decomposition should be applied

Definition at line 116 of file decomposedsensitivitystream.hpp.

◆ refDataManager_

QuantLib::ext::shared_ptr<ore::data::ReferenceDataManager> refDataManager_

private

refDataManager holding the equity and commodity index decomposition weights

Definition at line 118 of file decomposedsensitivitystream.hpp.

◆ curveConfigs_

QuantLib::ext::shared_ptr<ore::data::CurveConfigurations> curveConfigs_

private

Definition at line 119 of file decomposedsensitivitystream.hpp.

◆ ssd_

QuantLib::ext::shared_ptr<SensitivityScenarioData> ssd_

private

Definition at line 120 of file decomposedsensitivitystream.hpp.

◆ todaysMarket_

QuantLib::ext::shared_ptr<ore::data::Market> todaysMarket_

private

Definition at line 122 of file decomposedsensitivitystream.hpp.

◆ decompose_

bool decompose_

private

Definition at line 124 of file decomposedsensitivitystream.hpp.

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DecomposedSensitivityStream()

Member Function Documentation

◆ next()

◆ reset()

◆ constituentSpotRiskFromDecomposition()

◆ fxRiskFromDecomposition()

◆ fxRiskShiftSize()

◆ fxRiskShiftSizes()

◆ assetSpotShiftSize()

◆ equitySpotShiftSize()

◆ commoditySpotShiftSize()

◆ getConstituentCurrencies()

◆ decompose()

◆ decomposeSurvivalProbability()

◆ decomposeCurrencyHedgedIndexRisk()

◆ indexDecomposition()

◆ sensitivityRecords()

◆ curveCurrency()

Member Data Documentation

◆ decomposedRecords_

◆ itCurrent_

◆ ss_

◆ baseCurrency_

◆ defaultRiskDecompositionWeights_

◆ eqComDecompositionTradeIds_

◆ currencyHedgedIndexQuantities_

◆ refDataManager_

◆ curveConfigs_

◆ ssd_

◆ todaysMarket_

◆ decompose_