SimmConcentrationBase Class Reference

#include <orea/simm/simmconcentration.hpp>

Inheritance diagram for SimmConcentrationBase:

Collaboration diagram for SimmConcentrationBase:

Public Member Functions
	SimmConcentrationBase ()
QuantLib::Real	threshold (const CrifRecord::RiskType &riskType, const std::string &qualifier) const override
Public Member Functions inherited from SimmConcentration
virtual	~SimmConcentration ()
	Destructor. More...
virtual QuantLib::Real	threshold (const CrifRecord::RiskType &riskType, const std::string &qualifier) const =0

Protected Member Functions
QuantLib::Real	thresholdImpl (const QuantLib::ext::shared_ptr< SimmBucketMapper > &simmBucketMapper, const CrifRecord::RiskType &riskType, const std::string &qualifier) const
QuantLib::Real	fxVolThreshold (const std::string &fxPair) const
	Return concentration threshold for Risk_FXVol given the fxPair. More...
std::string	category (const std::string &qualifier, const std::map< std::string, std::set< std::string > > &categories) const
	Find the concentration threshold category of the qualifier. More...

Protected Attributes
QuantLib::Real	units_
	The units of quotation of the threshold amount e.g. $1MM. More...
std::map< CrifRecord::RiskType, QuantLib::Real >	flatThresholds_
std::map< CrifRecord::RiskType, std::map< std::string, QuantLib::Real > >	bucketedThresholds_
std::map< std::string, std::set< std::string > >	irCategories_
std::map< std::string, std::set< std::string > >	fxCategories_
QuantLib::ext::shared_ptr< SimmBucketMapper >	simmBucketMapper_
	Maps SIMM qualifiers to SIMM buckets. More...

Detailed Description

Definition at line 47 of file simmconcentration.hpp.

Constructor & Destructor Documentation

SimmConcentrationBase()

SimmConcentrationBase

(

)

Default ctor. May need to generalise if units of threshold quotation change significantly

Definition at line 55 of file simmconcentration.hpp.

: units_(1000000) {}

Member Function Documentation

threshold()

QuantLib::Real threshold ( const CrifRecord::RiskType &  riskType, const std::string &  qualifier  ) const

overridevirtual

Early versions of SIMM did not have concentration thresholds assigned. This base class just returns the maximum real number i.e. effectively no concentration threshold

Implements SimmConcentration.

Reimplemented in SimmConcentrationCalibration, SimmConcentration_ISDA_V1_3, SimmConcentration_ISDA_V1_3_38, SimmConcentration_ISDA_V2_0, SimmConcentration_ISDA_V2_1, SimmConcentration_ISDA_V2_2, SimmConcentration_ISDA_V2_3, SimmConcentration_ISDA_V2_3_8, SimmConcentration_ISDA_V2_5, SimmConcentration_ISDA_V2_5A, and SimmConcentration_ISDA_V2_6.

Definition at line 61 of file simmconcentration.hpp.

                                                                                                          {
        return QL_MAX_REAL;
    }

thresholdImpl()

Real thresholdImpl ( const QuantLib::ext::shared_ptr< SimmBucketMapper > &  simmBucketMapper, const CrifRecord::RiskType &  riskType, const std::string &  qualifier  ) const

protected

Shared threshold implementation for derived classes to call

Definition at line 39 of file simmconcentration.cpp.

                                                                                                   {
 
    // Deal with some specific cases first
    if (riskType == RiskType::IRCurve || riskType == RiskType::IRVol || riskType == RiskType::FX) {
 
        QL_REQUIRE(qualifier.size() == 3, "Expect the qualifier, " << qualifier << ", to be a valid currency code");
        QL_REQUIRE(checkCurrency(qualifier),
                   "The qualifier, " << qualifier << ", is not a supported currency code");
        auto cat = riskType == RiskType::FX ? category(qualifier, fxCategories_) : category(qualifier, irCategories_);
 
        return bucketedThresholds_.at(riskType).at(cat) * units_;
    }
 
    if (riskType == RiskType::FXVol) {
        return fxVolThreshold(qualifier) * units_;
    }
 
    // Check if the risk type's threshold is not bucket dependent and if so return the threshold
    if (flatThresholds_.count(riskType) > 0) {
        return flatThresholds_.at(riskType) * units_;
    }
 
    // Check if the risk type's threshold is bucket dependent and if so, find the bucket and return the threshold
    if (bucketedThresholds_.count(riskType) > 0) {
        string bucket = simmBucketMapper->bucket(riskType, qualifier);
        bucket = bucket == "residual" ? "Residual" : bucket;
        auto const& m = bucketedThresholds_.at(riskType);
        auto const& t = m.find(bucket);
        QL_REQUIRE(t != m.end(), "SimmConcentrationBase::thresholdImpl(): bucket '"
                                     << bucket << "' not found in bucketedThresholds for qualifier '" << qualifier
                                     << "' and risk type '" << riskType << "'");
        return t->second * units_;
    }
 
    // If we get to here, no threshold
    return QL_MAX_REAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fxVolThreshold()

Real fxVolThreshold ( const std::string &  fxPair ) const

protected

Return concentration threshold for Risk_FXVol given the fxPair.

Definition at line 95 of file simmconcentration.cpp.

                                                                     {
 
    QL_REQUIRE(fxPair.size() == 6, "Expected '" << fxPair << "' to be a currency pair so it should be of length 6.");
 
    string ccy_1 = fxPair.substr(0, 3);
    QL_REQUIRE(checkCurrency(ccy_1),
               "First currency in pair " << fxPair << " (" << ccy_1 << ") is not a supported currency code");
    string ccy_2 = fxPair.substr(3);
    QL_REQUIRE(checkCurrency(ccy_2),
               "Second currency in pair " << fxPair << " (" << ccy_2 << ") is not a supported currency code");
 
    // Find category of currency 1 and currency 2
    string category_1 = category(ccy_1, fxCategories_);
    string category_2 = category(ccy_2, fxCategories_);
 
    if (category_1 == "1" && category_2 == "1") {
        // Both currencies in FX category 1
        return bucketedThresholds_.at(RiskType::FXVol).at("1");
    } else if ((category_1 == "1" && category_2 == "2") || (category_1 == "2" && category_2 == "1")) {
        // One currency in FX category 1 and the other in FX category 2
        return bucketedThresholds_.at(RiskType::FXVol).at("2");
    } else if ((category_1 == "1" && category_2 == "3") || (category_1 == "3" && category_2 == "1")) {
        // One currency in FX category 1 and the other in FX category 3
        return bucketedThresholds_.at(RiskType::FXVol).at("3");
    } else if (category_1 == "2" && category_2 == "2") {
        // Both currencies in FX category 2
        return bucketedThresholds_.at(RiskType::FXVol).at("4");
    } else if ((category_1 == "2" && category_2 == "3") || (category_1 == "3" && category_2 == "2")) {
        // One currency in FX category 2 and the other in FX category 3
        return bucketedThresholds_.at(RiskType::FXVol).at("5");
    } else {
        // Both currencies in FX category 3
        return bucketedThresholds_.at(RiskType::FXVol).at("6");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

category()

string category ( const std::string &  qualifier, const std::map< std::string, std::set< std::string > > &  categories  ) const

protected

Find the concentration threshold category of the qualifier.

Definition at line 78 of file simmconcentration.cpp.

                                                                                                                {
    string result;
    for (const auto& kv : categories) {
        if (kv.second.empty()) {
            result = kv.first;
        } else {
            if (kv.second.count(qualifier) > 0) {
                // Found qualifier in category so return it
                return kv.first;
            }
        }
    }
 
    // If we get here, result should hold category with empty set
    return result;
}

Here is the caller graph for this function:

Member Data Documentation

units_

QuantLib::Real units_

protected

The units of quotation of the threshold amount e.g. $1MM.

Definition at line 67 of file simmconcentration.hpp.

flatThresholds_

std::map<CrifRecord::RiskType, QuantLib::Real> flatThresholds_

protected

Map from SIMM RiskType to another map that holds the SIMM concentration threshold bucket to threshold value mappings

Definition at line 72 of file simmconcentration.hpp.

bucketedThresholds_

std::map<CrifRecord::RiskType, std::map<std::string, QuantLib::Real> > bucketedThresholds_

protected

Map from SIMM RiskType to another map that holds the SIMM concentration threshold bucket to threshold value mappings

Definition at line 77 of file simmconcentration.hpp.

irCategories_

std::map<std::string, std::set<std::string> > irCategories_

protected

Map defining the currency groupings for IR concentration thresholds i.e. key is the category and value is the set of currencies in that category.

Definition at line 82 of file simmconcentration.hpp.

fxCategories_

std::map<std::string, std::set<std::string> > fxCategories_

protected

Map defining the currency groupings for concentration thresholds i.e. key is the category and value is the set of currencies in that category.

Definition at line 87 of file simmconcentration.hpp.

simmBucketMapper_

QuantLib::ext::shared_ptr<SimmBucketMapper> simmBucketMapper_

protected

Maps SIMM qualifiers to SIMM buckets.

Definition at line 90 of file simmconcentration.hpp.