ZeroToParCube Class Reference

ZeroToParCube class. More...

#include <orea/engine/zerotoparcube.hpp>

Collaboration diagram for ZeroToParCube:

Public Member Functions
	ZeroToParCube (const QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > &zeroCube, const QuantLib::ext::shared_ptr< ParSensitivityConverter > &parConverter, const std::set< ore::analytics::RiskFactorKey::KeyType > &typesDisabled={}, const bool continueOnError=false)
	Constructor. More...
	ZeroToParCube (const std::vector< QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > > &zeroCubes, const QuantLib::ext::shared_ptr< ParSensitivityConverter > &parConverter, const std::set< ore::analytics::RiskFactorKey::KeyType > &typesDisabled={}, const bool continueOnError=false)
	Another Constructor! More...
const std::vector< QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > > &	zeroCubes () const
	Inspectors. More...
const QuantLib::ext::shared_ptr< ParSensitivityConverter > &	parConverter () const
	Par converter object. More...
const std::set< ore::analytics::RiskFactorKey::KeyType > &	typesDisabled () const
	The par risk factor types that are disabled for this instance of ZeroToParCube. More...
std::map< ore::analytics::RiskFactorKey, QuantLib::Real >	parDeltas (const std::string &tradeId) const
	Return the non-zero par deltas for the given tradeId. More...
std::map< ore::analytics::RiskFactorKey, QuantLib::Real >	parDeltas (QuantLib::Size cubeIdx, QuantLib::Size tradeIdx) const
	Return the non-zero par deltas for the given cube and trade index. More...

Private Attributes
std::vector< QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > >	zeroCubes_
QuantLib::ext::shared_ptr< ParSensitivityConverter >	parConverter_
std::map< ore::analytics::RiskFactorKey, Size >	factorToIndex_
std::set< ore::analytics::RiskFactorKey::KeyType >	typesDisabled_
	Set of risk factor types available for par conversion but that are disabled for this instance of ZeroToParCube. More...
const bool	continueOnError_

Detailed Description

ZeroToParCube class.

Takes a cube of zero sensitivities, a par sensitivity converter and can return the par deltas for a given trade ID from the cube.

Definition at line 38 of file zerotoparcube.hpp.

Constructor & Destructor Documentation

ZeroToParCube() [1/2]

ZeroToParCube	(	const QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > &	zeroCube,
		const QuantLib::ext::shared_ptr< ParSensitivityConverter > &	parConverter,
		const std::set< ore::analytics::RiskFactorKey::KeyType > &	typesDisabled = {},
		const bool	continueOnError = false
	)

Constructor.

ZeroToParCube() [2/2]

ZeroToParCube	(	const std::vector< QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > > &	zeroCubes,
		const QuantLib::ext::shared_ptr< ParSensitivityConverter > &	parConverter,
		const std::set< ore::analytics::RiskFactorKey::KeyType > &	typesDisabled = {},
		const bool	continueOnError = false
	)

Another Constructor!

Member Function Documentation

zeroCubes()

const std::vector< QuantLib::ext::shared_ptr< ore::analytics::SensitivityCube > > & zeroCubes

(

)

const

Inspectors.

Underlying zero sensitivity cubes

Definition at line 54 of file zerotoparcube.hpp.

{ return zeroCubes_; }

parConverter()

const QuantLib::ext::shared_ptr< ParSensitivityConverter > & parConverter

(

)

const

Par converter object.

Definition at line 56 of file zerotoparcube.hpp.

{ return parConverter_; }

typesDisabled()

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

(

)

const

The par risk factor types that are disabled for this instance of ZeroToParCube.

Definition at line 58 of file zerotoparcube.hpp.

{ return typesDisabled_; }

parDeltas() [1/2]

map< RiskFactorKey, Real > parDeltas

(

const std::string &

tradeId

)

const

Return the non-zero par deltas for the given tradeId.

Definition at line 120 of file zerotoparcube.cpp.

                                                                             {
 
    DLOG("Calculating par deltas for trade " << tradeId);
    map<RiskFactorKey, Real> result;
 
    Size cubeIdx;
    Size tradeIdx = Null<Size>();
    for (cubeIdx = 0; cubeIdx < zeroCubes_.size() && tradeIdx == Null<Size>(); ++cubeIdx) {
        try {
            tradeIdx = zeroCubes_[cubeIdx]->npvCube()->getTradeIndex(tradeId);
            break;
        } catch (...) {
        }
    }
    QL_REQUIRE(tradeIdx != Null<Size>(), "ZeroToParCube::parDeltas(): tradeId '"
                                             << tradeId << "' not found in " << zeroCubes_.size() << " zero cubes.");
 
    result = parDeltas(cubeIdx, tradeIdx);
 
    DLOG("Finished calculating par deltas for trade " << tradeId);
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parDeltas() [2/2]

map< RiskFactorKey, Real > parDeltas	(	QuantLib::Size	cubeIdx,
		QuantLib::Size	tradeIdx
	)		const

Return the non-zero par deltas for the given cube and trade index.

Definition at line 55 of file zerotoparcube.cpp.

                                                                                                   {
 
    DLOG("Calculating par deltas for trade index " << tradeIdx);
 
    map<RiskFactorKey, Real> result;
 
    // Get the "par-convertible" zero deltas
    boost::numeric::ublas::vector<Real> zeroDeltas(parConverter_->rawKeys().size(), 0.0);
 
    QL_REQUIRE(cubeIdx < zeroCubes_.size(),
               "ZeroToParCube::parDeltas(): cubeIdx (" << cubeIdx << ") out of range 0..." << (zeroCubes_.size() - 1));
 
    const QuantLib::ext::shared_ptr<SensitivityCube>& zeroCube = zeroCubes_[cubeIdx];
    const QuantLib::ext::shared_ptr<NPVSensiCube>& sensiCube = zeroCube->npvCube();
 
    std::set<RiskFactorKey> rkeys;
    for (auto const& kv : sensiCube->getTradeNPVs(tradeIdx)) {
        if (auto k = zeroCube->upDownFactor(kv.first); k.keytype != RiskFactorKey::KeyType::None)
            rkeys.insert(k);
    }
 
    for (auto const& rk : rkeys) {
        auto it = factorToIndex_.find(rk);
        if (it == factorToIndex_.end()) {
            if (ParSensitivityAnalysis::isParType(rk.keytype) && typesDisabled_.count(rk.keytype) != 1) {
                if (continueOnError_) {
                    StructuredAnalyticsErrorMessage("Par conversion", "",
                                                    "Par factor " + ore::data::to_string(rk) +
                                                        " not found in factorToIndex map")
                        .log();
                } else {
                    QL_REQUIRE(!ParSensitivityAnalysis::isParType(rk.keytype) || typesDisabled_.count(rk.keytype) == 1,
                               "ZeroToParCube::parDeltas(): par factor " << rk << " not found in factorToIndex map");
                }
            }
        } else {
            zeroDeltas[it->second] = zeroCube->delta(tradeIdx, rk);
        }
    }
 
    // Convert the zero deltas to par deltas
    boost::numeric::ublas::vector<Real> parDeltas = parConverter_->convertSensitivity(zeroDeltas);
    Size counter = 0;
    for (const auto& key : parConverter_->parKeys()) {
        if (!close(parDeltas[counter], 0.0)) {
            result[key] = parDeltas[counter];
        }
        counter++;
    }
 
    // Add non-zero deltas that do not need to be converted from underlying zero cube
    for (const auto& f : rkeys) {
        if (!ParSensitivityAnalysis::isParType(f.keytype) || typesDisabled_.count(f.keytype) == 1) {
            Real delta = zeroCube->delta(tradeIdx, f);
            if (!close(delta, 0.0)) {
                result[f] = delta;
            }
        }
    }
 
    DLOG("Finished calculating par deltas for cube index " << cubeIdx << ", trade index " << tradeIdx);
 
    return result;
}

Here is the call graph for this function:

Member Data Documentation

zeroCubes_

std::vector<QuantLib::ext::shared_ptr<ore::analytics::SensitivityCube> > zeroCubes_

private

Definition at line 69 of file zerotoparcube.hpp.

parConverter_

QuantLib::ext::shared_ptr<ParSensitivityConverter> parConverter_

private

Definition at line 70 of file zerotoparcube.hpp.

factorToIndex_

std::map<ore::analytics::RiskFactorKey, Size> factorToIndex_

private

Definition at line 71 of file zerotoparcube.hpp.

typesDisabled_

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

private

Set of risk factor types available for par conversion but that are disabled for this instance of ZeroToParCube.

Definition at line 74 of file zerotoparcube.hpp.

continueOnError_

const bool continueOnError_

private

Definition at line 75 of file zerotoparcube.hpp.