SensitivityCubeStream Class Reference

#include <orea/engine/sensitivitycubestream.hpp>

Inheritance diagram for SensitivityCubeStream:

Collaboration diagram for SensitivityCubeStream:

Public Member Functions
	SensitivityCubeStream (const QuantLib::ext::shared_ptr< SensitivityCube > &cube, const std::string &currency)
	SensitivityCubeStream (const std::vector< QuantLib::ext::shared_ptr< SensitivityCube > > &cubes, const std::string &currency)
SensitivityRecord	next () override
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
void	updateForNewTrade ()

Private Attributes
std::vector< QuantLib::ext::shared_ptr< SensitivityCube > >	cubes_
	Handle on the SensitivityCubes. More...
std::string	currency_
	Currency of the sensitivities in the SensitivityCubes. More...
Size	currentCubeIdx_
	Current cube index in vector. More...
std::set< RiskFactorKey >	currentDeltaKeys_
	Current delta risk factor keys to process and iterators. More...
std::set< std::pair< RiskFactorKey, RiskFactorKey > >	currentCrossGammaKeys_
std::set< RiskFactorKey >::const_iterator	currentDeltaKey_
std::set< std::pair< RiskFactorKey, RiskFactorKey > >::const_iterator	currentCrossGammaKey_
std::map< std::string, QuantLib::Size >::const_iterator	tradeIdx_
	Current trade iterator. More...
bool	canComputeGamma_
	Can only compute gamma if the up and down risk factors align. More...

Detailed Description

Class for streaming SensitivityRecords from a SensitivityCube

Definition at line 37 of file sensitivitycubestream.hpp.

Constructor & Destructor Documentation

SensitivityCubeStream() [1/2]

SensitivityCubeStream	(	const QuantLib::ext::shared_ptr< SensitivityCube > &	cube,
		const std::string &	currency
	)

Constructor providing the sensitivity cube and currency of the sensitivities

Definition at line 33 of file sensitivitycubestream.cpp.

    : SensitivityCubeStream(std::vector<QuantLib::ext::shared_ptr<SensitivityCube>>{cube}, currency) {}

SensitivityCubeStream() [2/2]

SensitivityCubeStream	(	const std::vector< QuantLib::ext::shared_ptr< SensitivityCube > > &	cubes,
		const std::string &	currency
	)

Constructor providing the sensitivity cubes and currency of the sensitivities

Definition at line 36 of file sensitivitycubestream.cpp.

    : cubes_(cubes), currency_(currency), canComputeGamma_(false) {
 
    // Set the value of canComputeGamma_ based on up and down risk factors.
 
    canComputeGamma_ = true;
    for (const auto& cube : cubes_) {
        const auto& upFactors = cube->upFactors();
        const auto& downFactors = cube->downFactors();
        if (upFactors.size() == downFactors.size() &&
            equal(upFactors.begin(), upFactors.end(), downFactors.begin(),
                  [](const auto& a, const auto& b) { return a.first == b.first; }))
            continue;
        canComputeGamma_ = false;
        break;
    }
 
    reset();
}

Here is the call graph for this function:

Member Function Documentation

next()

SensitivityRecord next ( )

overridevirtual

Returns the next SensitivityRecord in the stream

Warning:

the cube must not change during successive calls to next()!

Implements SensitivityStream.

Definition at line 57 of file sensitivitycubestream.cpp.

                                              {
 
    if (cubes_.size() == 0)
        return SensitivityRecord();
 
    while (tradeIdx_ != cubes_[currentCubeIdx_]->tradeIdx().end() && currentDeltaKey_ == currentDeltaKeys_.end() &&
           currentCrossGammaKey_ == currentCrossGammaKeys_.end()) {
        ++tradeIdx_;
        updateForNewTrade();
    }
 
    if (tradeIdx_ == cubes_[currentCubeIdx_]->tradeIdx().end()) {
        if (currentCubeIdx_ < cubes_.size() - 1) {
            ++currentCubeIdx_;
            tradeIdx_ = cubes_[currentCubeIdx_]->tradeIdx().begin();
            updateForNewTrade();
            return next();
        } else {
            return SensitivityRecord();
        }
    }
 
    SensitivityRecord sr;
    Size tradeIdx = tradeIdx_->second;
    sr.tradeId = tradeIdx_->first;
    sr.isPar = false;
    sr.currency = currency_;
    sr.baseNpv = cubes_[currentCubeIdx_]->npv(tradeIdx);
 
    if (currentDeltaKey_ != currentDeltaKeys_.end()) {
        auto fd = cubes_[currentCubeIdx_]->upFactors().at(*currentDeltaKey_);
        sr.key_1 = *currentDeltaKey_;
        sr.desc_1 = fd.factorDesc;
        sr.shift_1 = fd.targetShiftSize;
        sr.delta = cubes_[currentCubeIdx_]->delta(tradeIdx_->first, *currentDeltaKey_);
        if (canComputeGamma_)
            sr.gamma = cubes_[currentCubeIdx_]->gamma(tradeIdx_->first, *currentDeltaKey_);
        else
            sr.gamma = Null<Real>();
        ++currentDeltaKey_;
    } else if (currentCrossGammaKey_ != currentCrossGammaKeys_.end()) {
        auto fd = cubes_[currentCubeIdx_]->crossFactors().at(*currentCrossGammaKey_);
        sr.key_1 = currentCrossGammaKey_->first;
        sr.desc_1 = std::get<0>(fd).factorDesc;
        sr.shift_1 = std::get<0>(fd).targetShiftSize;
        sr.key_2 = currentCrossGammaKey_->second;
        sr.desc_2 = std::get<1>(fd).factorDesc;
        sr.shift_2 = std::get<1>(fd).targetShiftSize;
        sr.gamma = cubes_[currentCubeIdx_]->crossGamma(tradeIdx_->first, *currentCrossGammaKey_);
        ++currentCrossGammaKey_;
    }
 
    TLOG("Next record is: " << sr);
    return sr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void reset ( )

overridevirtual

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

Implements SensitivityStream.

Definition at line 147 of file sensitivitycubestream.cpp.

                                  {
    currentCubeIdx_ = 0;
    if (cubes_.size() > 0) {
        tradeIdx_ = cubes_[currentCubeIdx_]->tradeIdx().begin();
        updateForNewTrade();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateForNewTrade()

void updateForNewTrade ( )

private

Definition at line 113 of file sensitivitycubestream.cpp.

                                              {
    currentDeltaKeys_.clear();
    currentCrossGammaKeys_.clear();
 
    if (tradeIdx_ != cubes_[currentCubeIdx_]->tradeIdx().end()) {
 
        // add delta keys
 
        for (auto const& [idx, _] : cubes_[currentCubeIdx_]->npvCube()->getTradeNPVs(tradeIdx_->second)) {
            if (auto k = cubes_[currentCubeIdx_]->upDownFactor(idx); k.keytype != RiskFactorKey::KeyType::None)
                currentDeltaKeys_.insert(k);
        }
 
        // add cross gamma keys
 
        for (auto const& [crossPair, data] : cubes_[currentCubeIdx_]->crossFactors()) {
            // scaling of cross gamma is not relevant here, so we use 1
            if (!close_enough(cubes_[currentCubeIdx_]->crossGamma(tradeIdx_->second, std::get<0>(data).index,
                                                                  std::get<1>(data).index, std::get<2>(data), 1.0, 1.0),
                              0.0)) {
                currentCrossGammaKeys_.insert(crossPair);
 
                // make sure, delta keys contain both cross keys, that's a guarantee of the SensitivityCubeStream
 
                currentDeltaKeys_.insert(crossPair.first);
                currentDeltaKeys_.insert(crossPair.second);
            }
        }
    }
 
    currentDeltaKey_ = currentDeltaKeys_.begin();
    currentCrossGammaKey_ = currentCrossGammaKeys_.begin();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cubes_

std::vector<QuantLib::ext::shared_ptr<SensitivityCube> > cubes_

private

Handle on the SensitivityCubes.

Definition at line 57 of file sensitivitycubestream.hpp.

currency_

std::string currency_

private

Currency of the sensitivities in the SensitivityCubes.

Definition at line 59 of file sensitivitycubestream.hpp.

currentCubeIdx_

Size currentCubeIdx_

private

Current cube index in vector.

Definition at line 62 of file sensitivitycubestream.hpp.

currentDeltaKeys_

std::set<RiskFactorKey> currentDeltaKeys_

private

Current delta risk factor keys to process and iterators.

Definition at line 65 of file sensitivitycubestream.hpp.

currentCrossGammaKeys_

std::set<std::pair<RiskFactorKey,RiskFactorKey> > currentCrossGammaKeys_

private

Definition at line 66 of file sensitivitycubestream.hpp.

currentDeltaKey_

std::set<RiskFactorKey>::const_iterator currentDeltaKey_

private

Definition at line 68 of file sensitivitycubestream.hpp.

currentCrossGammaKey_

std::set<std::pair<RiskFactorKey,RiskFactorKey>>::const_iterator currentCrossGammaKey_

private

Definition at line 69 of file sensitivitycubestream.hpp.

tradeIdx_

std::map<std::string,QuantLib::Size>::const_iterator tradeIdx_

private

Current trade iterator.

Definition at line 72 of file sensitivitycubestream.hpp.

canComputeGamma_

bool canComputeGamma_

private

Can only compute gamma if the up and down risk factors align.

Definition at line 75 of file sensitivitycubestream.hpp.