SensitivityAggregator Class Reference

#include <orea/engine/sensitivityaggregator.hpp>

Collaboration diagram for SensitivityAggregator:

Public Types
typedef std::pair< RiskFactorKey, RiskFactorKey >	CrossPair

Public Member Functions
	SensitivityAggregator (const std::map< std::string, std::set< std::pair< std::string, QuantLib::Size > > > &categories)
	SensitivityAggregator (const std::map< std::string, std::function< bool(std::string)> > &categories)
void	aggregate (SensitivityStream &ss, const QuantLib::ext::shared_ptr< ScenarioFilter > &filter=QuantLib::ext::make_shared< ScenarioFilter >())
void	reset ()
	Reset the aggregator to it's initial state by clearing all aggregations. More...
const std::set< SensitivityRecord > &	sensitivities (const std::string &category) const
void	generateDeltaGamma (const std::string &category, std::map< RiskFactorKey, QuantLib::Real > &deltas, std::map< CrossPair, QuantLib::Real > &gammas)

Private Member Functions
void	init ()
	Initialise the container of aggregated records. More...
void	add (SensitivityRecord &sr, std::set< SensitivityRecord > &records)
	Add a sensitivity record to the set of aggregated records. More...
bool	inCategory (const std::string &tradeId, const std::string &category) const
	Determine if the tradeId is in the given category. More...

Private Attributes
std::map< std::string, std::set< std::pair< std::string, QuantLib::Size > > >	setCategories_
std::map< std::string, std::function< bool(std::string)> >	categories_
	Container for category names and their definition via functions. More...
std::map< std::string, std::set< SensitivityRecord > >	aggRecords_
	Sensitivity records aggregated according to categories_ More...

Detailed Description

Class for aggregating SensitivityRecords.

The SensitivityRecords are aggregated according to categories of predefined trade IDs.

Definition at line 40 of file sensitivityaggregator.hpp.

Member Typedef Documentation

CrossPair

typedef std::pair<RiskFactorKey, RiskFactorKey> CrossPair

Return the deltas and gammas for the given category

Definition at line 75 of file sensitivityaggregator.hpp.

Constructor & Destructor Documentation

SensitivityAggregator() [1/2]

SensitivityAggregator

(

const std::map< std::string, std::set< std::pair< std::string, QuantLib::Size > > > &

categories

)

Constructor that uses sets of trades to define the aggregation categories.

The categories map has a string key that defines the name of the category and a value that defines the set of trade IDs in that category.

SensitivityAggregator() [2/2]

SensitivityAggregator

(

const std::map< std::string, std::function< bool(std::string)> > &

categories

)

Constructor that uses functions to define the aggregation categories.

The categories map has a string key that defines the name of the category. The map value is a function that when given a trade ID, returns a bool indicating if the trade ID is in the category.

Member Function Documentation

aggregate()

void aggregate	(	SensitivityStream &	ss,
		const QuantLib::ext::shared_ptr< ScenarioFilter > &	filter = QuantLib::ext::make_shared<ScenarioFilter>()
	)

Update the aggregator with SensitivityRecords from the stream ss after applying the optional filter. If no filter is specified, all risk factors are aggregated.

Warning:

No checks are performed for duplicate records from the stream. It is the stream's responsibility to guard against duplicates if it needs to.

Definition at line 52 of file sensitivityaggregator.cpp.

                                                                                                                {
    // Ensure at start of stream
    ss.reset();
 
    // Loop over stream's records
    while (SensitivityRecord sr = ss.next()) {
        // Skip this record if the risk factor is not in the filter
        if (!sr.isCrossGamma() && !filter->allow(sr.key_1))
            continue;
        if (sr.isCrossGamma() && (!filter->allow(sr.key_1) || !filter->allow(sr.key_2)))
            continue;
 
        // "Blank out" trade ID before adding
        string tradeId = sr.tradeId;
        sr.tradeId = "";
 
        // Update aggRecords_ for each category
        for (const auto& kv : categories_) {
            // Check if the sensitivity record's trade ID is in the category
            if (kv.second(tradeId)) {
                DLOG("Updating aggregated sensitivities for category " << kv.first << " with record: " << sr);
                add(sr, aggRecords_[kv.first]);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void reset

(

)

Reset the aggregator to it's initial state by clearing all aggregations.

Definition at line 79 of file sensitivityaggregator.cpp.

                                  {
    // Clear the aggregated sensitivities
    aggRecords_.clear();
 
    // Initialise the categorised records
    init();
}

sensitivities()

const set< SensitivityRecord > & sensitivities

(

const std::string &

category

)

const

Return the set of aggregated sensitivities for the given category

Definition at line 87 of file sensitivityaggregator.cpp.

                                                                                               {
 
    auto it = aggRecords_.find(category);
    QL_REQUIRE(it != aggRecords_.end(),
               "The category " << category << " was not used in the construction of the SensitivityAggregator");
 
    return it->second;
}

Here is the caller graph for this function:

generateDeltaGamma()

void generateDeltaGamma	(	const std::string &	category,
		std::map< RiskFactorKey, QuantLib::Real > &	deltas,
		std::map< CrossPair, QuantLib::Real > &	gammas
	)

Definition at line 96 of file sensitivityaggregator.cpp.

                                  {
 
    auto srs = sensitivities(category);
    for (const auto& sr : srs) {
        if (!sr.isCrossGamma()) {
            QL_REQUIRE(deltas.count(sr.key_1) == 0,
                       "Duplicate sensitivity entry for risk factor key " << sr.key_1 << " in the set");
            deltas[sr.key_1] = sr.delta;
            gammas[std::make_pair(sr.key_1, sr.key_1)] = sr.gamma;
        } else {
            auto keyPair =
                sr.key_1 < sr.key_2 ? std::make_pair(sr.key_1, sr.key_2) : std::make_pair(sr.key_2, sr.key_1);
            QL_REQUIRE(gammas.count(keyPair) == 0, "Duplicate sensitivity entry for cross gamma pair ["
                                                       << keyPair.first << ", " << keyPair.second << "] in the set");
            gammas[keyPair] = sr.gamma;
        }
    }
 
    // Final check that all cross gamma keys are in delta keys
    for (const auto& kv : gammas) {
        QL_REQUIRE(deltas.count(kv.first.first) > 0,
                   "The key " << kv.first.first << " is in the cross gammas but not in the deltas");
        QL_REQUIRE(deltas.count(kv.first.second) > 0,
                   "The key " << kv.first.second << " is in the cross gammas but not in the deltas");
    }
}

init()

void init ( )

private

Initialise the container of aggregated records.

Definition at line 124 of file sensitivityaggregator.cpp.

                                 {
    // Add an empty set for each of the categories
    for (const auto& kv : categories_) {
        aggRecords_[kv.first] = {};
    }
}

add()

void add ( SensitivityRecord &  sr, std::set< SensitivityRecord > &  records  )

private

Add a sensitivity record to the set of aggregated records.

Definition at line 131 of file sensitivityaggregator.cpp.

                                                                                      {
    // Try to insert sr. This will only pass if sr is not there already.
    auto p = records.insert(sr);
    if (!p.second) {
        // If sr is already in the set, update it.
        p.first->baseNpv += sr.baseNpv;
        p.first->delta += sr.delta;
        p.first->gamma += sr.gamma;
    }
}

inCategory()

bool inCategory ( const std::string &  tradeId, const std::string &  category  ) const

private

Determine if the tradeId is in the given category.

Definition at line 142 of file sensitivityaggregator.cpp.

                                                                                          {
    QL_REQUIRE(setCategories_.count(category), "The category " << category << " is not valid");
    auto tradeIds = setCategories_.at(category);
    for (auto it = tradeIds.begin(); it != tradeIds.end(); ++it) {
        if (it->first == tradeId)
            return true;
    }
    return false;
}

Member Data Documentation

setCategories_

std::map<std::string, std::set<std::pair<std::string, QuantLib::Size> > > setCategories_

private

Container for category names and their definition via sets. This will be empty if constructor is provided functions directly.

Definition at line 83 of file sensitivityaggregator.hpp.

categories_

std::map<std::string, std::function<bool(std::string)> > categories_

private

Container for category names and their definition via functions.

Definition at line 85 of file sensitivityaggregator.hpp.

aggRecords_

std::map<std::string, std::set<SensitivityRecord> > aggRecords_

private

Sensitivity records aggregated according to categories_

Definition at line 87 of file sensitivityaggregator.hpp.