#include <orea/simm/simmbucketmapperbase.hpp>

Inheritance diagram for SimmBucketMapperBase:

Collaboration diagram for SimmBucketMapperBase:

Public Member Functions
	SimmBucketMapperBase (const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &refDataManager=nullptr, const QuantLib::ext::shared_ptr< SimmBasicNameMapper > &nameMapper=nullptr)
	Default constructor that adds fixed known mappings. More...

std::string	bucket (const CrifRecord::RiskType &riskType, const std::string &qualifier) const override

bool	hasBuckets (const CrifRecord::RiskType &riskType) const override
	Check if the given SIMM RiskType has a bucket structure. More...

bool	has (const CrifRecord::RiskType &riskType, const std::string &qualifier, boost::optional< bool > fallback=boost::none) const override
	Check if the given `riskType` and `qualifier` has a valid mapping. More...

Public Member Functions inherited from SimmBucketMapper
virtual	~SimmBucketMapper ()
	Destructor. More...

virtual std::string	bucket (const CrifRecord::RiskType &riskType, const std::string &qualifier) const =0

virtual bool	hasBuckets (const CrifRecord::RiskType &riskType) const =0
	Check if the given SIMM RiskType has a bucket structure. More...

virtual bool	has (const CrifRecord::RiskType &riskType, const std::string &qualifier, boost::optional< bool > fallback=boost::none) const =0
	Check if the given `riskType` and `qualifier` has a mapping (which is valid, and matches the fallback flag if given) More...

virtual void	addMapping (const CrifRecord::RiskType &riskType, const std::string &qualifier, const std::string &bucket, const std::string &validFrom="", const std::string &validTo="", bool fallback=false)=0
	Add a single `bucket` mapping for `qualifier` with risk type `riskType`. More...

virtual const std::set< FailedMapping > &	failedMappings () const =0

void	updateFromCrif (const ore::analytics::Crif &crif)

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

virtual XMLNode *	toXML (XMLDocument &doc) const=0

void	fromFile (const std::string &filename)

void	toFile (const std::string &filename) const

void	fromXMLString (const std::string &xml)

std::string	toXMLString () const

Serialisation
std::map< CrifRecord::RiskType, std::map< std::string, std::set< BucketMapping > > >	bucketMapping_

std::set< CrifRecord::RiskType >	rtWithBuckets_
	Set of SIMM risk types that have buckets. More...

std::map< std::pair< CrifRecord::RiskType, std::string >, std::string >	cache_

QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager >	refDataManager_
	Reference data manager. More...

QuantLib::ext::shared_ptr< SimmBasicNameMapper >	nameMapper_
	Simm Name Mapper. More...

std::set< FailedMapping >	failedMappings_

ore::data::XMLNode *	toXML (ore::data::XMLDocument &) const override

void	fromXML (ore::data::XMLNode *node) override

void	addMapping (const CrifRecord::RiskType &riskType, const std::string &qualifier, const std::string &bucket, const std::string &validFrom="", const std::string &validTo="", bool fallback=false) override
	Add a single `bucket` mapping for `qualifier` with risk type `riskType`. More...

void	setSimmNameMapper (const QuantLib::ext::shared_ptr< SimmBasicNameMapper > nameMapper)
	Set the Reference data manager. More...

void	setRefDataManger (const QuantLib::ext::shared_ptr< ore::data::BasicReferenceDataManager > &refDataManager)
	Set the Reference data manager. More...

const std::set< FailedMapping > &	failedMappings () const override

virtual std::string	irBucket (const std::string &qualifier) const

void	checkRiskType (const CrifRecord::RiskType &riskType) const
	Check the risk type before adding a mapping entry. More...

void	reset ()
	Reset the SIMM bucket mapper i.e. clears all mappings and adds the initial hard-coded commodity mappings. More...

Detailed Description

Definition at line 58 of file simmbucketmapperbase.hpp.

Constructor & Destructor Documentation

◆ SimmBucketMapperBase()

SimmBucketMapperBase	(	const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &	refDataManager = `nullptr`,
		const QuantLib::ext::shared_ptr< SimmBasicNameMapper > &	nameMapper = `nullptr`
	)

Default constructor that adds fixed known mappings.

Definition at line 52 of file simmbucketmapperbase.cpp.

                                                                  :
    refDataManager_(refDataManager), nameMapper_(nameMapper){
 
    // Fill the set of risk types that have buckets
    rtWithBuckets_ = {RiskType::IRCurve,       RiskType::CreditQ,      RiskType::CreditNonQ,   RiskType::Equity,
                      RiskType::Commodity,     RiskType::IRVol,        RiskType::InflationVol, RiskType::CreditVol,
                      RiskType::CreditVolNonQ, RiskType::EquityVol,    RiskType::CommodityVol};
}

Member Function Documentation

◆ bucket()

string bucket	(	const CrifRecord::RiskType &	riskType,
		const std::string &	qualifier
	)		const

overridevirtual

Return the SIMM bucket for a given SIMM RiskType and SIMM Qualifier. An error is thrown if there is no bucket for the combination.

Implements SimmBucketMapper.

Definition at line 87 of file simmbucketmapperbase.cpp.

                                                                                           {
 
    auto key = std::make_pair(riskType, qualifier);
    if (auto b = cache_.find(key); b != cache_.end())
        return b->second;
 
    QL_REQUIRE(hasBuckets(riskType), "The risk type " << riskType << " does not have buckets");
 
    // Vol risk type bucket mappings are stored in their non-vol counterparts
    auto lookupRiskType = riskType;
    auto nv = nonVolRiskTypeMap.find(riskType);
    if (nv != nonVolRiskTypeMap.end()) {
        lookupRiskType = nv->second;
    }
 
    // Deal with RiskType::IRCurve
    if (lookupRiskType == RiskType::IRCurve || lookupRiskType == RiskType::GIRR_DELTA) {
        auto tmp = irBucket(qualifier);
        cache_[key] = tmp;
        return tmp;
    }
 
    string bucket;
    string lookupName = qualifier;
 
    bool haveMapping = has(lookupRiskType, lookupName, false);
    bool haveFallback = has(lookupRiskType, lookupName, true);
    bool noBucket = !haveMapping && !haveFallback;
 
    if (noBucket && nameMapper_ != nullptr &&
        (lookupRiskType == RiskType::Equity || lookupRiskType == RiskType::EQ_DELTA)) {
        // if we have a simm name mapping we do a reverse lookup on the name as the CRIF qualifier isn't in reference data
        lookupName = nameMapper_->externalName(qualifier);
        haveMapping = has(lookupRiskType, lookupName, false);
        noBucket = !haveMapping && !haveFallback;
    }
 
    // Do some checks and return the lookup
    if (noBucket) {
        if (lookupRiskType == RiskType::Commodity) {
            bool commIndex = false;
            // first check is there is an entry under equity reference, this may tell us if it is an index
            if (refDataManager_ != nullptr && refDataManager_->hasData("Equity", lookupName)) {
                auto refData = QuantLib::ext::dynamic_pointer_cast<ore::data::EquityReferenceDatum>(
                    refDataManager_->getData("Equity", lookupName));
                if (refData->equityData().isIndex)
                    commIndex = true;
            }
 
            
            // Commodity does not allow "Residual", but bucket 16 is "Other", bucket 17 for Indices
            // FAQ Methodology and implementation 20180124 (H3) says to use "Other"
            bucket = commIndex ? "17" : "16";                        
            TLOG("Don't have any bucket mappings for the "
                << "combination of risk type " << riskType << " and qualifier " << lookupName
                << " - assigning to bucket " << bucket);
 
        } else if (lookupRiskType == RiskType::Equity) {
            // check if it is an index
            if (refDataManager_ != nullptr && refDataManager_->hasData("Equity", lookupName)) {
                auto refData = QuantLib::ext::dynamic_pointer_cast<ore::data::EquityReferenceDatum>(refDataManager_->getData("Equity", lookupName));
                // if the equity is an index we assign to bucket 11
                if (refData->equityData().isIndex) {
                    TLOG("Don't have any bucket mappings for the "
                        << "combination of risk type " << riskType << " and qualifier " << lookupName
                        << " - assigning to bucket 11");
                    bucket = "11";
                }
            }
        } 
        
        if (bucket.empty()) {
            TLOG("Don't have any bucket mappings for the "
                << "combination of risk type " << riskType << " and qualifier " << lookupName
                << " - assigning to Residual/Other bucket");
            bucket = "Residual";
        }
 
        FailedMapping fm;
        fm.name = qualifier;
        fm.lookupName = lookupName;
        fm.riskType = riskType;
        fm.lookupRiskType = lookupRiskType;
        failedMappings_.insert(fm);
 
    } else {
        // We may have several mappings per qualifier, pick the first valid one that matches the fallback flag
        Date today = Settings::instance().evaluationDate();
        for (auto m : bucketMapping_.at(lookupRiskType).at(lookupName)) {
            if (m.validToDate() >= today && m.validFromDate() <= today && m.fallback() == !haveMapping) {
                bucket = m.bucket();
                cache_[key] = bucket;
                return bucket;
            }
        }
        TLOG("bucket mapping for risk type " << riskType << " and qualifier " << qualifier << " inactive, return Residual");
        bucket = "Residual";
    }
 
    cache_[key] = bucket;
    return bucket;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasBuckets()

bool hasBuckets ( const CrifRecord::RiskType & riskType ) const

overridevirtual

Check if the given SIMM RiskType has a bucket structure.

Implements SimmBucketMapper.

Definition at line 190 of file simmbucketmapperbase.cpp.

190{ return rtWithBuckets_.count(riskType) > 0; }

Here is the caller graph for this function:

◆ has()

bool has	(	const CrifRecord::RiskType &	riskType,
		const std::string &	qualifier,
		boost::optional< bool >	fallback = `boost::none`
	)		const

overridevirtual

Check if the given riskType and qualifier has a valid mapping.

Implements SimmBucketMapper.

Definition at line 192 of file simmbucketmapperbase.cpp.

                                                                   {
 
    // Vol risk type bucket mappings are stored in their non-vol counterparts
    auto lookupRiskType = riskType;
    auto nv = nonVolRiskTypeMap.find(riskType);
    if (nv != nonVolRiskTypeMap.end()) {
        lookupRiskType = nv->second;
    }
 
    if (lookupRiskType == RiskType::IRCurve || lookupRiskType == RiskType::GIRR_DELTA)
        return true;
 
    auto bm = bucketMapping_.find(lookupRiskType);
    if (bm == bucketMapping_.end())
        return false;
 
    auto q = bm->second.find(qualifier);
    if (q == bm->second.end())
        return false;
 
    Date today = Settings::instance().evaluationDate();
 
    // We may have several mappings (several periods, override and fallback mappings)
    // So pick the first valid one
 
    for (const auto& m : q->second) {
        Date validTo = m.validToDate();
        Date validFrom = m.validFromDate();
        if (validTo >= today && validFrom <= today && (fallback ? *fallback == m.fallback() : true))
            return true;
    }
    return false;
}

Here is the caller graph for this function:

◆ toXML()

XMLNode * toXML ( ore::data::XMLDocument & doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 298 of file simmbucketmapperbase.cpp.

                                                                  {
    XMLNode* node = doc.allocNode("SIMMBucketMappings");
    for (auto const& b : bucketMapping_) {
        XMLNode* n = doc.allocNode(ore::data::to_string(b.first));
        XMLUtils::appendNode(node, n);
        for (auto const& bms : b.second) {
            for (auto const& bm : bms.second) {
                XMLNode* m = doc.allocNode("Mapping");
                XMLUtils::appendNode(n, m);
                if (!bms.first.empty())
                    XMLUtils::addChild(doc, m, "Qualifier", bms.first);
                if (!bm.validTo().empty())
                    XMLUtils::addChild(doc, m, "ValidTo", bm.validTo());
                if (!bm.validFrom().empty())
                    XMLUtils::addChild(doc, m, "ValidFrom", bm.validFrom());
                if (!bm.bucket().empty())
                    XMLUtils::addChild(doc, m, "Bucket", bm.bucket());
                if (bm.fallback())
                    XMLUtils::addChild(doc, m, "Fallback", bm.fallback());
            }
        }
    }
    return node;
}

Here is the call graph for this function:

◆ fromXML()

void fromXML ( ore::data::XMLNode * node )

overridevirtual

Implements XMLSerializable.

Definition at line 227 of file simmbucketmapperbase.cpp.

                                                {
    XMLUtils::checkNode(node, "SIMMBucketMappings");
 
    // Every time a call to fromXML is made, reset the bucket mapper to its initial state
    reset();
 
    LOG("Start parsing SIMMBucketMappings");
 
    for (XMLNode* rtNode = XMLUtils::getChildNode(node); rtNode; rtNode = XMLUtils::getNextSibling(rtNode)) {
        // Get the risk type that we are dealing with
        string strRiskType = XMLUtils::getNodeName(rtNode);
        RiskType riskType = parseRiskType(strRiskType);
 
        checkRiskType(riskType);
 
        QL_REQUIRE(bucketMapping_.count(riskType) == 0,
                   "Can only have one node for each risk type. " << strRiskType << " appears more than once.");
        bucketMapping_[riskType] = {};
 
        // Loop over and add the bucket mappings for this risk type
        for (XMLNode* mappingNode = XMLUtils::getChildNode(rtNode, "Mapping"); mappingNode;
             mappingNode = XMLUtils::getNextSibling(mappingNode, "Mapping")) {
 
            string validTo = XMLUtils::getChildValue(mappingNode, "ValidTo", false);
            string validFrom = XMLUtils::getChildValue(mappingNode, "ValidFrom", false);
            string qualifier = XMLUtils::getChildValue(mappingNode, "Qualifier", false);
            string bucket = XMLUtils::getChildValue(mappingNode, "Bucket", false);
            if (bucket == "" || qualifier == "") {
                ALOG("skip bucket mapping for quaifier '" << qualifier << "' and bucket '" << bucket << "'");
                continue;
            }
            string fallbackString = XMLUtils::getChildValue(mappingNode, "Fallback", false);
            bool fallback = false;
            if (fallbackString != "")
                fallback = ore::data::parseBool(fallbackString);
 
            if (validTo != "") {
                // Check whether the provided validTo element is a valid date, ALERT and ignore if it is not
                try {
                    ore::data::parseDate(validTo);
                } catch(std::exception&) {
                    ALOG("Cannot parse bucket mapping validTo " << validTo << " for qualifier " << qualifier << ", ignore");
                    validTo = "";
                }
            }  
            if (validFrom != "") {
                // Check whether the provided validFrom element is a valid date, ALERT and ignore if it is not
                try {
                    ore::data::parseDate(validFrom);
                } catch(std::exception&) {
                    ALOG("Cannot parse bucket mapping validFrom " << validFrom << " for qualifier " << qualifier << ", ignore");
                    validFrom = "";
                }
            }  
 
            // Add mapping
            BucketMapping mapping(bucket, validFrom, validTo, fallback);
            if (bucketMapping_[riskType].find(qualifier) == bucketMapping_[riskType].end())
                bucketMapping_[riskType][qualifier] = std::set<BucketMapping>();
            bucketMapping_[riskType][qualifier].insert(mapping);
            TLOG("Added SIMM bucket mapping: {" << riskType << ": {" << qualifier << ", " << bucket << ", " << validFrom << ", " << validTo << ", " << fallback << "}}");
            if (bucket != "Residual") {
                int bucketInt = ore::data::parseInteger(bucket);
                QL_REQUIRE(bucketInt >= 1, "found bucket " << bucket << ", expected >= 1"); 
            }
        }
    }
 
    LOG("Finished parsing SIMMBucketMappings");
}

Here is the call graph for this function:

◆ addMapping()

void addMapping	(	const CrifRecord::RiskType &	riskType,
		const std::string &	qualifier,
		const std::string &	bucket,
		const std::string &	validFrom = `""`,
		const std::string &	validTo = `""`,
		bool	fallback = `false`
	)

overridevirtual

Add a single bucket mapping for qualifier with risk type riskType.

Implements SimmBucketMapper.

Definition at line 323 of file simmbucketmapperbase.cpp.

                                                                                                     {
 
    cache_.clear();
 
    // Possibly map to non-vol counterpart for lookup
    RiskType rt = riskType;
    if (nonVolRiskTypeMap.count(riskType) > 0) {
        rt = nonVolRiskTypeMap.at(riskType);
    }
 
    if (rt == RiskType::IRCurve) {
        // IR has internal mapping so return early - no need for warning
        // Could catch commodity here but allow extra mappings there
        return;
    }
 
    QL_REQUIRE(hasBuckets(riskType),
               "Tried to add a bucket mapping for risk type " << riskType << " but it does not have buckets.");
 
    if (bucketMapping_[rt].find(qualifier) == bucketMapping_[rt].end())
        bucketMapping_[rt][qualifier] = std::set<BucketMapping>();
 
    std::string vf = validFrom, vt = validTo;
    if (vf != "") {
        try {
            ore::data::parseDate(vf);
        } catch(std::exception& e) {
            ALOG("Error parsing validFrom date, ignore: " << e.what());
            vf = "";
        }
    }
    if (vt != "") {
        try {
            ore::data::parseDate(vt);
        } catch(std::exception& e) {
            ALOG("Error parsing validTo date, ignore: " << e.what());
            vt = "";
        }
    }
    
    bucketMapping_[rt][qualifier].insert(BucketMapping(bucket, vt, vf, fallback));
}

Here is the call graph for this function:

◆ setSimmNameMapper()

void setSimmNameMapper ( const QuantLib::ext::shared_ptr< SimmBasicNameMapper > nameMapper )

Set the Reference data manager.

Definition at line 93 of file simmbucketmapperbase.hpp.

93{ nameMapper_ = nameMapper; }

◆ setRefDataManger()

void setRefDataManger ( const QuantLib::ext::shared_ptr< ore::data::BasicReferenceDataManager > & refDataManager )

Set the Reference data manager.

Definition at line 96 of file simmbucketmapperbase.hpp.

96{ refDataManager_ = refDataManager; }

◆ failedMappings()

const std::set< FailedMapping > & failedMappings ( ) const

overridevirtual

Implements SimmBucketMapper.

Definition at line 98 of file simmbucketmapperbase.hpp.

98{ return failedMappings_; }

◆ irBucket()

string irBucket ( const std::string & qualifier ) const

protectedvirtual

Simple logic for RiskType Risk_IRCurve. Qualifier is a currency code and this is checked here.

Definition at line 367 of file simmbucketmapperbase.cpp.

                                                                   {
    if (qualifier == "USD" || qualifier == "EUR" || qualifier == "GBP" || qualifier == "AUD" || qualifier == "CAD" ||
        qualifier == "CHF" || qualifier == "DKK" || qualifier == "HKD" || qualifier == "KRW" || qualifier == "NOK" ||
        qualifier == "NZD" || qualifier == "SEK" || qualifier == "SGD" || qualifier == "TWD")
        return "1";
    if (qualifier == "JPY")
        return "2";
    return "3";
}

Here is the caller graph for this function:

◆ checkRiskType()

void checkRiskType ( const CrifRecord::RiskType & riskType ) const

protected

Check the risk type before adding a mapping entry.

Definition at line 377 of file simmbucketmapperbase.cpp.

                                                                       {
    QL_REQUIRE(riskType != RiskType::IRCurve, "Risk type " << RiskType::IRCurve << " is mapped to buckets internally.");
 
    QL_REQUIRE(hasBuckets(riskType), "The risk type " << riskType << " does not have buckets.");
 
    QL_REQUIRE(nonVolRiskTypeMap.count(riskType) == 0, "The vol risk type "
                                                           << "mappings are stored in their non-vol counterparts. Use "
                                                           << nonVolRiskTypeMap.at(riskType) << " instead of "
                                                           << riskType << ".");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

void reset ( )

private

Reset the SIMM bucket mapper i.e. clears all mappings and adds the initial hard-coded commodity mappings.

Definition at line 388 of file simmbucketmapperbase.cpp.

                                 {
    cache_.clear();
    // Clear the bucket mapper and add back the commodity mappings
    bucketMapping_.clear();
    failedMappings_.clear();
}

Here is the caller graph for this function:

Member Data Documentation

◆ bucketMapping_

std::map<CrifRecord::RiskType, std::map<std::string, std::set<BucketMapping> > > bucketMapping_

protected

Map from SIMM RiskType to another map that holds the SIMM Qualifier to SIMM bucket mappings

Definition at line 112 of file simmbucketmapperbase.hpp.

◆ rtWithBuckets_

std::set<CrifRecord::RiskType> rtWithBuckets_

protected

Set of SIMM risk types that have buckets.

Definition at line 115 of file simmbucketmapperbase.hpp.

◆ cache_

std::map<std::pair<CrifRecord::RiskType, std::string>, std::string> cache_

mutableprivate

Definition at line 118 of file simmbucketmapperbase.hpp.

◆ refDataManager_

QuantLib::ext::shared_ptr<ore::data::ReferenceDataManager> refDataManager_

private

Reference data manager.

Definition at line 124 of file simmbucketmapperbase.hpp.

◆ nameMapper_

QuantLib::ext::shared_ptr<SimmBasicNameMapper> nameMapper_

private

Simm Name Mapper.

Definition at line 127 of file simmbucketmapperbase.hpp.

◆ failedMappings_

std::set<FailedMapping> failedMappings_

mutableprivate

Definition at line 129 of file simmbucketmapperbase.hpp.

Public Member Functions

Serialisation

Detailed Description

Constructor & Destructor Documentation

◆ SimmBucketMapperBase()

Member Function Documentation

◆ bucket()

◆ hasBuckets()

◆ has()

◆ toXML()

◆ fromXML()

◆ addMapping()

◆ setSimmNameMapper()

◆ setRefDataManger()

◆ failedMappings()

◆ irBucket()

◆ checkRiskType()

◆ reset()

Member Data Documentation

◆ bucketMapping_

◆ rtWithBuckets_

◆ cache_

◆ refDataManager_

◆ nameMapper_

◆ failedMappings_