ParSensitivityAnalysis Class Reference

Par Sensitivity Analysis. More...

#include <orea/engine/parsensitivityanalysis.hpp>

Collaboration diagram for ParSensitivityAnalysis:

Public Types
typedef std::map< std::pair< ore::analytics::RiskFactorKey, ore::analytics::RiskFactorKey >, Real >	ParContainer

Public Member Functions
	ParSensitivityAnalysis (const QuantLib::Date &asof, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &simMarketParams, const ore::analytics::SensitivityScenarioData &sensitivityData, const string &marketConfiguration=Market::defaultConfiguration, const bool continueOnError=false, const std::set< ore::analytics::RiskFactorKey::KeyType > &typesDisabled={})
	Constructor. More...
virtual	~ParSensitivityAnalysis ()
void	computeParInstrumentSensitivities (const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &simMarket)
	Compute par instrument sensitivities. More...
const ParContainer &	parSensitivities () const
	Return computed par sensitivities. Empty if they have not been computed yet. More...
void	alignPillars ()
	align pillars in scenario simulation market parameters with those of the par instruments More...
const std::set< ore::analytics::RiskFactorKey > &	relevantRiskFactors () const
	get / set the relevant scenarios (if empty, these are ignored) More...
std::set< ore::analytics::RiskFactorKey > &	relevantRiskFactors ()
std::map< ore::analytics::RiskFactorKey, std::pair< QuantLib::Real, QuantLib::Real > >	shiftSizes () const
	Return the zero rate and par rate absolute shift size for each risk factor key. More...
void	disable (const std::set< ore::analytics::RiskFactorKey::KeyType > &types)
const std::set< ore::analytics::RiskFactorKey::KeyType > &	typesDisabled () const
	Return the set of key types disabled for this instance of ParSensitivityAnalysis. More...
const ParSensitivityInstrumentBuilder::Instruments &	parInstruments () const

Static Public Member Functions
static bool	isParType (ore::analytics::RiskFactorKey::KeyType type)
	Returns true if risk factor type is applicable for par conversion. More...

Private Member Functions
void	augmentRelevantRiskFactors ()
	Augment relevant risk factors. More...
void	populateShiftSizes (const ore::analytics::RiskFactorKey &key, QuantLib::Real parRate, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &simMarket)
	Populate shiftSizes_ for key given the implied fair par rate parRate. More...

Private Attributes
QuantLib::Date	asof_
	As of date for the calculation of the par sensitivities. More...
QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters >	simMarketParams_
	Simulation market parameters. More...
ore::analytics::SensitivityScenarioData	sensitivityData_
	Sensitivity data. More...
ParContainer	parSensi_
	sensitivity of par rates w.r.t. raw rate shifts (including optionlet/cap volatility) More...
ParSensitivityInstrumentBuilder::Instruments	instruments_
std::string	marketConfiguration_
bool	continueOnError_
std::set< ore::analytics::RiskFactorKey >	relevantRiskFactors_
std::set< ore::analytics::RiskFactorKey::KeyType >	typesDisabled_
	Set of risk factor types disabled for this instance of ParSensitivityAnalysis. More...
std::map< ore::analytics::RiskFactorKey, std::pair< QuantLib::Real, QuantLib::Real > >	shiftSizes_

Static Private Attributes
static std::set< ore::analytics::RiskFactorKey::KeyType >	parTypes_

Detailed Description

Par Sensitivity Analysis.

This class adds par sensitivity conversion to the base class functionality

Definition at line 57 of file parsensitivityanalysis.hpp.

Member Typedef Documentation

ParContainer

typedef std::map<std::pair<ore::analytics::RiskFactorKey, ore::analytics::RiskFactorKey>, Real> ParContainer

Definition at line 59 of file parsensitivityanalysis.hpp.

Constructor & Destructor Documentation

ParSensitivityAnalysis()

ParSensitivityAnalysis	(	const QuantLib::Date &	asof,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &	simMarketParams,
		const ore::analytics::SensitivityScenarioData &	sensitivityData,
		const string &	marketConfiguration = Market::defaultConfiguration,
		const bool	continueOnError = false,
		const std::set< ore::analytics::RiskFactorKey::KeyType > &	typesDisabled = {}
	)

Constructor.

Definition at line 89 of file parsensitivityanalysis.cpp.

    : asof_(asof), simMarketParams_(simMarketParams), sensitivityData_(sensitivityData),
      marketConfiguration_(marketConfiguration), continueOnError_(continueOnError), typesDisabled_(typesDisabled) {
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
    QL_REQUIRE(conventions != nullptr, "conventions are empty");
    ParSensitivityInstrumentBuilder().createParInstruments(instruments_, asof_, simMarketParams_, sensitivityData_,
                                                           typesDisabled_, parTypes_, relevantRiskFactors_,
                                                           continueOnError_, marketConfiguration_, nullptr);
}

Here is the call graph for this function:

~ParSensitivityAnalysis()

virtual ~ParSensitivityAnalysis ( )

virtual

Definition at line 69 of file parsensitivityanalysis.hpp.

{}

Member Function Documentation

computeParInstrumentSensitivities()

void computeParInstrumentSensitivities

(

const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &

simMarket

)

Compute par instrument sensitivities.

Definition at line 154 of file parsensitivityanalysis.cpp.

                                                                                                                        {
 
    LOG("Cache base scenario par rates and flat vols");
 
    if (relevantRiskFactors_.empty()) {
        DLOG("Relevant risk factors not provided");
    } else {
        DLOG("Relevant risk factors provided:");
        for (auto const& rf : relevantRiskFactors_)
            DLOG("Relevant risk factor " << rf);
    }
 
    // remove todays fixings from relevant indices for the scope of this method
    struct TodaysFixingsRemover {
        TodaysFixingsRemover(const std::set<std::string>& names) : today_(Settings::instance().evaluationDate()) {
            Date today = Settings::instance().evaluationDate();
            for (auto const& n : names) {
                TimeSeries<Real> t = IndexManager::instance().getHistory(n);
                if (t[today] != Null<Real>()) {
                    DLOG("removing todays fixing (" << std::setprecision(6) << t[today] << ") from " << n);
                    savedFixings_.insert(std::make_pair(n, t[today]));
                    t[today] = Null<Real>();
                    IndexManager::instance().setHistory(n, t);
                }
            }
        }
        ~TodaysFixingsRemover() {
            for (auto const& p : savedFixings_) {
                TimeSeries<Real> t = IndexManager::instance().getHistory(p.first);
                t[today_] = p.second;
                IndexManager::instance().setHistory(p.first, t);
                DLOG("restored todays fixing (" << std::setprecision(6) << p.second << ") for " << p.first);
            }
        }
        const Date today_;
        std::set<std::pair<std::string, Real>> savedFixings_;
    };
    TodaysFixingsRemover fixingRemover(instruments_.removeTodaysFixingIndices_);
 
    // We must have a ShiftScenarioGenerator
    QuantLib::ext::shared_ptr<ScenarioGenerator> simMarketScenGen = simMarket->scenarioGenerator();
    QuantLib::ext::shared_ptr<ShiftScenarioGenerator> scenarioGenerator =
        QuantLib::ext::dynamic_pointer_cast<ShiftScenarioGenerator>(simMarketScenGen);
 
    struct SimMarketResetter {
        SimMarketResetter(QuantLib::ext::shared_ptr<SimMarket> simMarket) : simMarket_(simMarket) {}
        ~SimMarketResetter() { simMarket_->reset(); }
        QuantLib::ext::shared_ptr<SimMarket> simMarket_;
    } simMarketResetter(simMarket);
 
    simMarket->reset();
    scenarioGenerator->reset();
    simMarket->update(asof_);
 
    if (!relevantRiskFactors_.empty())
        augmentRelevantRiskFactors();
    ParSensitivityInstrumentBuilder().createParInstruments(instruments_, asof_, simMarketParams_, sensitivityData_,
                                                           typesDisabled_, parTypes_, relevantRiskFactors_,
                                                           continueOnError_, marketConfiguration_, simMarket);
 
    map<RiskFactorKey, Real> parRatesBase, parCapVols; // for both ir and yoy caps
 
    for (auto& p : instruments_.parHelpers_) {
        try {
            Real parRate = impliedQuote(p.second);
            parRatesBase[p.first] = parRate;
 
            // Populate zero and par shift size for the current risk factor
            populateShiftSizes(p.first, parRate, simMarket);
 
        } catch (const std::exception& e) {
            QL_FAIL("could not imply quote for par helper " << p.first << ": " << e.what());
        }
    }
 
    for (auto& c : instruments_.parCaps_) {
 
        QL_REQUIRE(instruments_.parCapsYts_.count(c.first) > 0,
                   "computeParInstrumentSensitivities(): no cap yts found for key " << c.first);
        QL_REQUIRE(instruments_.parCapsVts_.count(c.first) > 0,
                   "computeParInstrumentSensitivities(): no cap vts found for key " << c.first);
 
        Real price = c.second->NPV();
        Volatility parVol = impliedVolatility(
            *c.second, price, instruments_.parCapsYts_.at(c.first), 0.01,
            instruments_.parCapsVts_.at(c.first)->volatilityType(), instruments_.parCapsVts_.at(c.first)->displacement());
        parCapVols[c.first] = parVol;
        TLOG("Fair implied cap volatility for key " << c.first << " is " << std::fixed << std::setprecision(12)
                                                    << parVol << ".");
 
        // Populate zero and par shift size for the current risk factor
        populateShiftSizes(c.first, parVol, simMarket);
    }
 
    for (auto& c : instruments_.parYoYCaps_) {
 
        QL_REQUIRE(instruments_.parYoYCapsYts_.count(c.first) > 0,
                   "computeParInstrumentSensitivities(): no cap yts found for key " << c.first);
        QL_REQUIRE(instruments_.parYoYCapsIndex_.count(c.first) > 0,
                   "computeParInstrumentSensitivities(): no cap index found for key " << c.first);
        QL_REQUIRE(instruments_.parYoYCapsVts_.count(c.first) > 0,
                   "computeParInstrumentSensitivities(): no cap vts found for key " << c.first);
 
        Real price = c.second->NPV();
        Volatility parVol = impliedVolatility(
            *c.second, price, instruments_.parYoYCapsYts_.at(c.first), 0.01,
            instruments_.parYoYCapsVts_.at(c.first)->volatilityType(),
            instruments_.parYoYCapsVts_.at(c.first)->displacement(), instruments_.parYoYCapsIndex_.at(c.first));
        parCapVols[c.first] = parVol;
        TLOG("Fair implied yoy cap volatility for key " << c.first << " is " << std::fixed << std::setprecision(12)
                                                        << parVol << ".");
 
        // Populate zero and par shift size for the current risk factor
        populateShiftSizes(c.first, parVol, simMarket);
    }
 
    LOG("Caching base scenario par rates and float vols done.");
 
    /****************************************************************
     * Discount curve instrument fair rate sensitivity to zero shifts
     * Index curve instrument fair rate sensitivity to zero shifts
     * Cap/Floor flat vol sensitivity to optionlet vol shifts
     *
     * Step 3:
     * - Apply all single up-shift scenarios,
     * - Compute respective fair par rates and flat vols
     * - Compute par rate / flat vol sensitivities
     */
    LOG("Compute par rate and flat vol sensitivities");
 
    vector<ShiftScenarioGenerator::ScenarioDescription> desc = scenarioGenerator->scenarioDescriptions();
    QL_REQUIRE(desc.size() == scenarioGenerator->samples(),
               "descriptions size " << desc.size() << " does not match samples " << scenarioGenerator->samples());
 
    std::set<RiskFactorKey> parKeysCheck, parKeysNonZero;
    std::set<RiskFactorKey> rawKeysCheck, rawKeysNonZero;
 
    for (auto const& p : instruments_.parHelpers_) {
        parKeysCheck.insert(p.first);
    }
 
    for (auto const& p : instruments_.parCaps_) {
        parKeysCheck.insert(p.first);
    }
 
    for (auto const& p : instruments_.parYoYCaps_) {
        parKeysCheck.insert(p.first);
    }
 
    for (Size i = 1; i < scenarioGenerator->samples(); ++i) {
 
        simMarket->update(asof_);
 
        // use single "UP" shift scenarios only, use only scenarios relevant for par instruments,
        // use relevant scenarios only, if specified
        // ignore risk factor types that have been disabled
        if (desc[i].type() != ShiftScenarioGenerator::ScenarioDescription::Type::Up ||
            !isParType(desc[i].key1().keytype) || typesDisabled_.count(desc[i].key1().keytype) == 1 ||
            !(relevantRiskFactors_.empty() || relevantRiskFactors_.find(desc[i].key1()) != relevantRiskFactors_.end()))
            continue;
 
        // Since we are not using ValuationEngine we need to manually perform the trade updates here
        // TODO - explore means of utilising valuation engine
        if (ObservationMode::instance().mode() == ObservationMode::Mode::Disable) {
            for (auto it : instruments_.parHelpers_)
                it.second->deepUpdate();
            for (auto it : instruments_.parCaps_)
                it.second->deepUpdate();
            for (auto it : instruments_.parYoYCaps_)
                it.second->deepUpdate();
        }
 
        rawKeysCheck.insert(desc[i].key1());
 
        // Get the absolute shift size and skip if close to zero
 
        Real shiftSize = getShiftSize(desc[i].key1(), sensitivityData_, simMarket);
 
        if (close_enough(shiftSize, 0.0)) {
            ALOG("Shift size for " << desc[i].key1() << " is zero, skipping");
            continue;
        }
 
        // process par helpers
 
        std::set<RiskFactorKey::KeyType> survivalAndRateCurveTypes = {
            RiskFactorKey::KeyType::SurvivalProbability, RiskFactorKey::KeyType::DiscountCurve,
            RiskFactorKey::KeyType::YieldCurve, RiskFactorKey::KeyType::IndexCurve};
 
        for (auto const& p : instruments_.parHelpers_) {
 
            // skip if par helper has no sensi to zero risk factor (except the special treatment below kicks in)
 
            if (p.second->isCalculated() &&
                (survivalAndRateCurveTypes.find(p.first.keytype) == survivalAndRateCurveTypes.end() ||
                 p.first != desc[i].key1())) {
                continue;
            }
 
            // compute fair and base quotes
 
            Real fair = impliedQuote(p.second);
            auto base = parRatesBase.find(p.first);
            QL_REQUIRE(base != parRatesBase.end(), "internal error: did not find parRatesBase[" << p.first << "]");
 
            Real tmp = (fair - base->second) / shiftSize;
 
            // special treatments for certain risk factors
 
            // for curves with survival probabilities / discount factors going to zero quickly we might see a
            // sensitivity that is close to zero, which we sanitise here in order to prevent the Jacobi matrix
            // getting ill-conditioned or even singular
 
            if (survivalAndRateCurveTypes.find(p.first.keytype) != survivalAndRateCurveTypes.end() &&
                p.first == desc[i].key1() && std::abs(tmp) < 0.01) {
                WLOG("Setting Diagonal Sensi " << p.first << " w.r.t. " << desc[i].key1() << " to 0.01 (got " << tmp
                                               << ")");
                tmp = 0.01;
            }
 
            // YoY diagnoal entries are 1.0
 
            if (p.first.keytype == RiskFactorKey::KeyType::YoYInflationCurve && p.first == desc[i].key1() &&
                close_enough(tmp, 0.0)) {
                tmp = 1.0;
            }
 
            // write sensitivity
 
            writeSensitivity(p.first, desc[i].key1(), tmp, parSensi_, parKeysNonZero, rawKeysNonZero);
        }
 
        // process par caps
 
        for (auto const& p : instruments_.parCaps_) {
 
            if (p.second->isCalculated() && p.first != desc[i].key1())
                continue;
 
            auto fair = impliedVolatility(p.first, instruments_);
            auto base = parCapVols.find(p.first);
            QL_REQUIRE(base != parCapVols.end(), "internal error: did not find parCapVols[" << p.first << "]");
 
            Real tmp = (fair - base->second) / shiftSize;
 
            // ensure Jacobi matrix is regular and not (too) ill-conditioned, this is necessary because
            // a) the shift size used to compute dpar / dzero might be close to zero and / or
            // b) the implied vol calculation has numerical inaccuracies
 
            if (p.first == desc[i].key1() && std::abs(tmp) < 0.01) {
                WLOG("Setting Diagonal CapFloorVol Sensi " << p.first << " w.r.t. " << desc[i].key1()
                                                           << " to 0.01 (got " << tmp << ")");
                tmp = 0.01;
            }
 
            // write sensitivity
 
            writeSensitivity(p.first, desc[i].key1(), tmp, parSensi_, parKeysNonZero, rawKeysNonZero);
        }
 
        // process par yoy caps
 
        for (auto const& p : instruments_.parYoYCaps_) {
 
            if (p.second->isCalculated() && p.first != desc[i].key1())
                continue;
 
            auto fair = impliedVolatility(p.first, instruments_);
            auto base = parCapVols.find(p.first);
            QL_REQUIRE(base != parCapVols.end(), "internal error: did not find parCapVols[" << p.first << "]");
 
            Real tmp = (fair - base->second) / shiftSize;
 
            // ensure Jacobi matrix is regular and not (too) ill-conditioned, this is necessary because
            // a) the shift size used to compute dpar / dzero might be close to zero and / or
            // b) the implied vol calculation has numerical inaccuracies
 
            if (p.first == desc[i].key1() && std::abs(tmp) < 0.01) {
                WLOG("Setting Diagonal CapFloorVol Sensi " << p.first << " w.r.t. " << desc[i].key1()
                                                           << " to 0.01 (got " << tmp << ")");
                tmp = 0.01;
            }
 
            // write sensitivity
 
            writeSensitivity(p.first, desc[i].key1(), tmp, parSensi_, parKeysNonZero, rawKeysNonZero);
        }
 
    } // end of loop over samples
 
    // check for
    // a) par instruments which have no sensitivity to any of the risk factors
    // b) risk factors w.r.t. which no par instrument has a sensitivity
    std::set<RiskFactorKey> parKeysZero, rawKeysZero;
    std::set_difference(parKeysCheck.begin(), parKeysCheck.end(), parKeysNonZero.begin(), parKeysNonZero.end(),
                        std::inserter(parKeysZero, parKeysZero.begin()));
    std::set_difference(rawKeysCheck.begin(), rawKeysCheck.end(), rawKeysNonZero.begin(), rawKeysNonZero.end(),
                        std::inserter(rawKeysZero, rawKeysZero.begin()));
    std::set<RiskFactorKey> problematicKeys;
    problematicKeys.insert(parKeysZero.begin(), parKeysZero.end());
    problematicKeys.insert(rawKeysZero.begin(), rawKeysZero.end());
    for (auto const& k : problematicKeys) {
        std::string type;
        if (parKeysZero.find(k) != parKeysZero.end())
            type = "par instrument is insensitive to all zero risk factors";
        else if (rawKeysZero.find(k) != rawKeysZero.end())
            type = "zero risk factor that does not affect an par instrument";
        else
            type = "unknown";
        Real parHelperValue = Null<Real>();
        if (auto tmp = instruments_.parHelpers_.find(k); tmp != instruments_.parHelpers_.end())
            parHelperValue = impliedQuote(tmp->second);
        else if (auto tmp = instruments_.parCaps_.find(k); tmp != instruments_.parCaps_.end())
            parHelperValue = tmp->second->NPV();
        else if (auto tmp = instruments_.parYoYCaps_.find(k); tmp != instruments_.parYoYCaps_.end())
            parHelperValue = tmp->second->NPV();
        Real zeroFactorValue = Null<Real>();
        if (simMarket->baseScenarioAbsolute()->has(k))
            zeroFactorValue = simMarket->baseScenarioAbsolute()->get(k);
        WLOG("zero/par relation problem for key '"
             << k << "', type " + type + ", par value = "
             << (parHelperValue == Null<Real>() ? "na" : std::to_string(parHelperValue))
             << ", zero value = " << (zeroFactorValue == Null<Real>() ? "na" : std::to_string(zeroFactorValue)));
    }
 
    LOG("Computing par rate and flat vol sensitivities done");
} // compute par instrument sensis

Here is the call graph for this function:

Here is the caller graph for this function:

parSensitivities()

const ParContainer & parSensitivities

(

)

const

Return computed par sensitivities. Empty if they have not been computed yet.

Definition at line 75 of file parsensitivityanalysis.hpp.

{ return parSensi_; }

Here is the caller graph for this function:

alignPillars()

void alignPillars

(

)

align pillars in scenario simulation market parameters with those of the par instruments

Definition at line 482 of file parsensitivityanalysis.cpp.

                                          {
    LOG("Align simulation market pillars to actual latest relevant dates of par instruments");
    // If any of the yield curve types are still active, align the pillars.
    if (typesDisabled_.count(RiskFactorKey::KeyType::DiscountCurve) == 0 ||
        typesDisabled_.count(RiskFactorKey::KeyType::YieldCurve) == 0 ||
        typesDisabled_.count(RiskFactorKey::KeyType::IndexCurve) == 0) {
        for (auto const& p : instruments_.yieldCurvePillars_) {
            simMarketParams_->setYieldCurveTenors(p.first, p.second);
            DLOG("yield curve tenors for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    if (typesDisabled_.count(RiskFactorKey::KeyType::OptionletVolatility) == 0) {
        for (auto const& p : instruments_.capFloorPillars_) {
            simMarketParams_->setCapFloorVolExpiries(p.first, p.second);
            DLOG("cap floor expiries for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    if (typesDisabled_.count(RiskFactorKey::KeyType::YoYInflationCapFloorVolatility) == 0) {
        for (auto const& p : instruments_.yoyCapFloorPillars_) {
            simMarketParams_->setYoYInflationCapFloorVolExpiries(p.first, p.second);
            DLOG("yoy cap floor expiries for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    if (typesDisabled_.count(RiskFactorKey::KeyType::SurvivalProbability) == 0) {
        for (auto const& p : instruments_.cdsPillars_) {
            simMarketParams_->setDefaultTenors(p.first, p.second);
            DLOG("default expiries for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    if (typesDisabled_.count(RiskFactorKey::KeyType::ZeroInflationCurve) == 0) {
        for (auto const& p : instruments_.zeroInflationPillars_) {
            simMarketParams_->setZeroInflationTenors(p.first, p.second);
            DLOG("zero inflation expiries for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    if (typesDisabled_.count(RiskFactorKey::KeyType::YoYInflationCurve) == 0) {
        for (auto const& p : instruments_.yoyInflationPillars_) {
            simMarketParams_->setYoyInflationTenors(p.first, p.second);
            DLOG("yoy inflation expiries for " << p.first << " set (" << p.second.size() << ")");
            for (auto const& t : p.second)
                TLOG("set tenor " << t.length() << " " << t.units())
        }
    }
    LOG("Alignment of pillars done.");
}

Here is the caller graph for this function:

isParType()

bool isParType ( ore::analytics::RiskFactorKey::KeyType  type )

static

Returns true if risk factor type is applicable for par conversion.

Definition at line 538 of file parsensitivityanalysis.cpp.

{ return parTypes_.find(type) != parTypes_.end(); }

Here is the caller graph for this function:

relevantRiskFactors() [1/2]

const std::set< ore::analytics::RiskFactorKey > & relevantRiskFactors

(

)

const

get / set the relevant scenarios (if empty, these are ignored)

Definition at line 84 of file parsensitivityanalysis.hpp.

{ return relevantRiskFactors_; }

relevantRiskFactors() [2/2]

std::set< ore::analytics::RiskFactorKey > & relevantRiskFactors

(

)

Definition at line 85 of file parsensitivityanalysis.hpp.

{ return relevantRiskFactors_; }

shiftSizes()

std::map< ore::analytics::RiskFactorKey, std::pair< QuantLib::Real, QuantLib::Real > > shiftSizes

(

)

const

Return the zero rate and par rate absolute shift size for each risk factor key.

Definition at line 88 of file parsensitivityanalysis.hpp.

                                                                                              {
        return shiftSizes_;
    }

Here is the caller graph for this function:

disable()

void disable

(

const std::set< ore::analytics::RiskFactorKey::KeyType > &

types

)

Disable par conversion for the given set of risk factor key types. May be called multiple times in order to add key types that should not be considered for par conversion.

Definition at line 540 of file parsensitivityanalysis.cpp.

                                                                           {
    // Insert only types that are available for par sensitivity analysis in to the set of disabled types.
    for (const auto& type : types) {
        if (isParType(type)) {
            typesDisabled_.insert(type);
        }
    }
}

Here is the call graph for this function:

typesDisabled()

const std::set< ore::analytics::RiskFactorKey::KeyType > & typesDisabled

(

)

const

Return the set of key types disabled for this instance of ParSensitivityAnalysis.

Definition at line 98 of file parsensitivityanalysis.hpp.

{ return typesDisabled_; }

parInstruments()

const ParSensitivityInstrumentBuilder::Instruments & parInstruments

(

)

const

Definition at line 100 of file parsensitivityanalysis.hpp.

{ return instruments_; }

augmentRelevantRiskFactors()

void augmentRelevantRiskFactors ( )

private

Augment relevant risk factors.

Definition at line 103 of file parsensitivityanalysis.cpp.

                                                        {
    LOG("Augment relevant risk factors, starting with " << relevantRiskFactors_.size() << " risk factors.");
    std::set<ore::analytics::RiskFactorKey> addFactors1 = relevantRiskFactors_, addFactors2, tmp;
    do {
        // DLOG("new pass with " << addFactors1.size() << " risk factors.");
        for (auto const& r : addFactors1) {
            // DLOG("candidate risk factor " << r);
            for (auto const& s : instruments_.parHelpers_) {
                if (riskFactorKeysAreSimilar(s.first, r)) {
                    tmp.insert(s.first);
                    // DLOG("factor " << r << ": found similar risk factor " << s.first);
                    for (auto const& d : instruments_.parHelperDependencies_[s.first]) {
                        if (std::find(relevantRiskFactors_.begin(), relevantRiskFactors_.end(), d) ==
                            relevantRiskFactors_.end())
                            addFactors2.insert(d);
                    }
                }
            }
            for (auto const& s : instruments_.parCaps_) {
                if (riskFactorKeysAreSimilar(s.first, r)) {
                    tmp.insert(s.first);
                    // DLOG("factor " << r << ": found similar risk factor " << s.first);
                    for (auto const& d : instruments_.parHelperDependencies_[s.first]) {
                        if (std::find(relevantRiskFactors_.begin(), relevantRiskFactors_.end(), d) ==
                            relevantRiskFactors_.end())
                            addFactors2.insert(d);
                    }
                }
            }
        }
        addFactors1.swap(addFactors2);
        addFactors2.clear();
        relevantRiskFactors_.insert(tmp.begin(), tmp.end());
        tmp.clear();
    } while (addFactors1.size() > 0);
    LOG("Done, relevant risk factor size now " << relevantRiskFactors_.size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

populateShiftSizes()

void populateShiftSizes ( const ore::analytics::RiskFactorKey &  key, QuantLib::Real  parRate, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarket > &  simMarket  )

private

Populate shiftSizes_ for key given the implied fair par rate parRate.

Definition at line 549 of file parsensitivityanalysis.cpp.

                                                                                                           {
 
    // Get zero and par shift size for the key
    Real zeroShiftSize = getShiftSize(key, sensitivityData_, simMarket);
    auto shiftData = sensitivityData_.shiftData(key.keytype, key.name);
    Real parShiftSize = shiftData.shiftSize;
    if (shiftData.shiftType == ShiftType::Relative)
        parShiftSize *= parRate;
 
    // Update the map
    shiftSizes_[key] = make_pair(zeroShiftSize, parShiftSize);
 
    TLOG("Zero and par shift size for risk factor '" << key << "' is (" << std::fixed << std::setprecision(12)
                                                     << zeroShiftSize << "," << parShiftSize << ")");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

asof_

QuantLib::Date asof_

private

As of date for the calculation of the par sensitivities.

Definition at line 111 of file parsensitivityanalysis.hpp.

simMarketParams_

QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarketParameters> simMarketParams_

private

Simulation market parameters.

Definition at line 113 of file parsensitivityanalysis.hpp.

sensitivityData_

ore::analytics::SensitivityScenarioData sensitivityData_

private

Sensitivity data.

Definition at line 115 of file parsensitivityanalysis.hpp.

parSensi_

ParContainer parSensi_

private

sensitivity of par rates w.r.t. raw rate shifts (including optionlet/cap volatility)

Definition at line 117 of file parsensitivityanalysis.hpp.

instruments_

ParSensitivityInstrumentBuilder::Instruments instruments_

private

Definition at line 118 of file parsensitivityanalysis.hpp.

marketConfiguration_

std::string marketConfiguration_

private

Definition at line 120 of file parsensitivityanalysis.hpp.

continueOnError_

bool continueOnError_

private

Definition at line 121 of file parsensitivityanalysis.hpp.

relevantRiskFactors_

std::set<ore::analytics::RiskFactorKey> relevantRiskFactors_

private

Definition at line 122 of file parsensitivityanalysis.hpp.

parTypes_

set< RiskFactorKey::KeyType > parTypes_

staticprivate

Initial value:

= {
    RiskFactorKey::KeyType::DiscountCurve,       RiskFactorKey::KeyType::YieldCurve,
    RiskFactorKey::KeyType::IndexCurve,          RiskFactorKey::KeyType::OptionletVolatility,
    RiskFactorKey::KeyType::SurvivalProbability, RiskFactorKey::KeyType::ZeroInflationCurve,
    RiskFactorKey::KeyType::YoYInflationCurve,   RiskFactorKey::KeyType::YoYInflationCapFloorVolatility}

Definition at line 124 of file parsensitivityanalysis.hpp.

typesDisabled_

std::set<ore::analytics::RiskFactorKey::KeyType> typesDisabled_

private

Set of risk factor types disabled for this instance of ParSensitivityAnalysis.

Definition at line 127 of file parsensitivityanalysis.hpp.

shiftSizes_

std::map<ore::analytics::RiskFactorKey, std::pair<QuantLib::Real, QuantLib::Real> > shiftSizes_

private

Store the zero rate and par rate absolute shift size for each risk factor key

The first element in the pair is the zero or raw rate absolute shift size. The second element in the pair is the corresponding par rate absolute shift size.

In the case of the zero rate shift being configured as Absolute in sensitivityData_, then the par rate absolute shift size is just equal to the configured zero rate shift size. In the case of the zero rate shift being configured as Relative in sensitivityData_, we take the fair implied par rate and multiply it by the configured relative zero rate shift size to give the par rate absolute shift size.

Definition at line 139 of file parsensitivityanalysis.hpp.