#include <orea/simm/imschedulecalculator.hpp>

Collaboration diagram for IMScheduleCalculator:

Classes
struct	IMScheduleTradeData

Public Types
typedef CrifRecord::ProductClass	ProductClass

typedef CrifRecord::RiskType	RiskType

typedef SimmConfiguration::Regulation	Regulation

typedef SimmConfiguration::SimmSide	SimmSide

Public Member Functions
	IMScheduleCalculator (const Crif &crif, const std::string &calculationCcy="USD", const QuantLib::ext::shared_ptr< ore::data::Market > market=nullptr, const bool determineWinningRegulations=true, const bool enforceIMRegulations=false, const bool quiet=false, const std::map< SimmSide, std::set< NettingSetDetails > > &hasSEC=std::map< SimmSide, std::set< NettingSetDetails > >(), const std::map< SimmSide, std::set< NettingSetDetails > > &hasCFTC=std::map< SimmSide, std::set< NettingSetDetails > >())
	Construct the IMScheduleCalculator from a container of netted CRIF records. More...

const std::map< SimmSide, std::set< std::string > >	finalTradeIds () const
	Give back the set of portfolio IDs and trade IDs for which we have IM results. More...

const std::string &	winningRegulations (const SimmSide &side, const ore::data::NettingSetDetails &nettingSetDetails) const
	Return the winning regulation for each portfolioId. More...

const std::map< ore::data::NettingSetDetails, string > &	winningRegulations (const SimmSide &side) const

const std::map< SimmSide, std::map< ore::data::NettingSetDetails, string > > &	winningRegulations () const

const std::map< std::string, IMScheduleResults > &	imScheduleSummaryResults (const SimmSide &side, const ore::data::NettingSetDetails &nsd) const
	Give back the IM Schedule results container for the given portfolioId and IM side. More...

const std::map< ore::data::NettingSetDetails, std::map< std::string, IMScheduleResults > > &	imScheduleSummaryResults (const SimmSide &side) const

const std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::map< std::string, IMScheduleResults > > > &	imScheduleSummaryResults () const

const std::pair< std::string, IMScheduleResults > &	finalImScheduleSummaryResults (const SimmSide &side, const ore::data::NettingSetDetails &nsd) const

const std::map< ore::data::NettingSetDetails, std::pair< std::string, IMScheduleResults > > &	finalImScheduleSummaryResults (const SimmSide &side) const

const std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::pair< std::string, IMScheduleResults > > > &	finalImScheduleSummaryResults () const

const std::vector< IMScheduleTradeData > &	imScheduleTradeResults (const std::string &tradeId) const
	Give back the IM Schedule results container for the given tradeId and IM side. More...

const std::map< std::string, std::vector< IMScheduleTradeData > > &	imScheduleTradeResults () const

const IMScheduleTradeData &	finalImScheduleTradeResults (const std::string &tradeId) const

const std::map< std::string, IMScheduleTradeData > &	finalImScheduleTradeResults () const

const std::string &	calculationCurrency () const
	Return the calculator's calculation currency. More...

void	populateFinalResults (const std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::string > > &winningRegulations)

Static Public Member Functions
static const IMScheduleLabel	label (const ProductClass &productClass, const QuantLib::Real &maturity)

static const std::string	labelString (const IMScheduleLabel &label)

Private Member Functions
QuantLib::Real	multiplier (const IMScheduleLabel &label)

void	collectTradeData (const CrifRecord &cr, const bool enforceIMRegulations)
	Collect trade data as defined by the CRIF records. More...

void	populateResults (const ore::data::NettingSetDetails &nsd, const string &regulation, const SimmSide &side)

void	populateFinalResults ()

void	add (const SimmSide &side, const ore::data::NettingSetDetails &nsd, const std::string &regulation, const CrifRecord::ProductClass &pc, const std::string &ccy, const QuantLib::Real &grossIM, const QuantLib::Real &grossRC=QuantLib::Null< QuantLib::Real >(), const QuantLib::Real &netRC=QuantLib::Null< QuantLib::Real >(), const QuantLib::Real &ngr=QuantLib::Null< QuantLib::Real >(), const QuantLib::Real &scheduleIM=QuantLib::Null< QuantLib::Real >())
	Add a margin result to either call or post results container depending on the SimmSide parameter. More...

Private Attributes
ore::analytics::Crif	crif_
	The net sensitivities used in the calculation. More...

std::string	calculationCcy_
	The SIMM calculation currency i.e. the currency of the SIMM results. More...

QuantLib::ext::shared_ptr< ore::data::Market >	market_
	Market data for FX rates to use for converting amounts to USD. More...

bool	quiet_
	If true, no logging is written out. More...

std::map< SimmSide, std::set< NettingSetDetails > >	hasSEC_

std::map< SimmSide, std::set< NettingSetDetails > >	hasCFTC_

std::map< ore::data::NettingSetDetails, bool >	collectRegsIsEmpty_
	For each netting set, whether all CRIF records' collect regulations are empty. More...

std::map< ore::data::NettingSetDetails, bool >	postRegsIsEmpty_
	For each netting set, whether all CRIF records' post regulations are empty. More...

std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::map< std::string, IMScheduleResults > > >	imScheduleResults_
	Containers, one for call and post, with an IMScheduleResults object for each regulation under each portfolio ID. More...

std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::pair< std::string, IMScheduleResults > > >	finalImScheduleResults_
	Containers, one for call and post, with an IMScheduleResults object for each portfolio ID. More...

std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::map< std::string, set< string > > > >	tradeIds_
	Container for keeping track of what trade IDs belong to each regulation. More...

std::map< SimmSide, set< string > >	finalTradeIds_

std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::string > >	winningRegulations_
	Regulation with highest IM for each given netting set. More...

std::map< std::string, std::vector< IMScheduleTradeData > >	finalTradeData_

std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::map< std::string, std::map< std::string, IMScheduleTradeData > > > >	nettingSetRegTradeData_
	Container for trade data, taking into account regulations applicable to each netting set. More...

std::map< IMScheduleLabel, QuantLib::Real >	multiplierMap_

Detailed Description

A class to calculate Schedule IM given a set of aggregated CRIF results for one or more portfolios.

Definition at line 35 of file imschedulecalculator.hpp.

Member Typedef Documentation

◆ ProductClass

typedef CrifRecord::ProductClass ProductClass

Definition at line 38 of file imschedulecalculator.hpp.

◆ RiskType

typedef CrifRecord::RiskType RiskType

Definition at line 39 of file imschedulecalculator.hpp.

◆ Regulation

typedef SimmConfiguration::Regulation Regulation

Definition at line 40 of file imschedulecalculator.hpp.

◆ SimmSide

typedef SimmConfiguration::SimmSide SimmSide

Definition at line 41 of file imschedulecalculator.hpp.

Constructor & Destructor Documentation

◆ IMScheduleCalculator()

IMScheduleCalculator	(	const Crif &	crif,
		const std::string &	calculationCcy = `"USD"`,
		const QuantLib::ext::shared_ptr< ore::data::Market >	market = `nullptr`,
		const bool	determineWinningRegulations = `true`,
		const bool	enforceIMRegulations = `false`,
		const bool	quiet = `false`,
		const std::map< SimmSide, std::set< NettingSetDetails > > &	hasSEC = `std::map<SimmSide, std::set<NettingSetDetails>>()`,
		const std::map< SimmSide, std::set< NettingSetDetails > > &	hasCFTC = `std::map<SimmSide, std::set<NettingSetDetails>>()`
	)

Construct the IMScheduleCalculator from a container of netted CRIF records.

Definition at line 53 of file imschedulecalculator.cpp.

    : crif_(crif), calculationCcy_(calculationCcy), market_(market), quiet_(quiet),
      hasSEC_(hasSEC), hasCFTC_(hasCFTC) {
 
    QL_REQUIRE(checkCurrency(calculationCcy_),
               "The calculation currency (" << calculationCcy_ << ") must be a valid ISO currency code");
 
    QuantLib::Date today = QuantLib::Settings::instance().evaluationDate();
    QuantLib::DayCounter dayCounter = QuantLib::ActualActual(QuantLib::ActualActual::ISDA);
 
    // Collect Schedule CRIF records
    Crif tmp;
    for (const CrifRecord& cr : crif_) {
        const bool isSchedule = cr.imModel == "Schedule";
 
        if (!isSchedule) {
            if (determineWinningRegulations) {
                ore::data::StructuredTradeWarningMessage(
                    cr.tradeId, cr.tradeType, "IM Schedule calculator",
                    "Skipping over CRIF record without im_model=Schedule for portfolio [ " +
                        to_string(cr.nettingSetDetails) + "]")
                    .log();
            }
            continue;
        }
 
        // Check for each netting set whether post/collect regs are populated at all
        if (collectRegsIsEmpty_.find(cr.nettingSetDetails) == collectRegsIsEmpty_.end()) {
            collectRegsIsEmpty_[cr.nettingSetDetails] = cr.collectRegulations.empty();
        } else if (collectRegsIsEmpty_.at(cr.nettingSetDetails) && !cr.collectRegulations.empty()) {
            collectRegsIsEmpty_.at(cr.nettingSetDetails) = false;
        }
        if (postRegsIsEmpty_.find(cr.nettingSetDetails) == postRegsIsEmpty_.end()) {
            postRegsIsEmpty_[cr.nettingSetDetails] = cr.postRegulations.empty();
        } else if (postRegsIsEmpty_.at(cr.nettingSetDetails) && !cr.postRegulations.empty()) {
            postRegsIsEmpty_.at(cr.nettingSetDetails) = false;
        }
 
        tmp.addRecord(cr);
    }
    crif_ = tmp;
 
 
    // Separate out CRIF records by regulations and collect per-trade data
    LOG("IMScheduleCalculator: Collecting CRIF trade data");
    for (const auto& crifRecord : crif_)
        collectTradeData(crifRecord, enforceIMRegulations);
 
    // Remove (or modify) trades with incomplete data
    for (auto& sv : nettingSetRegTradeData_) {
        const SimmSide& side = sv.first;
 
        for (auto& nv : sv.second) {
            const NettingSetDetails& nsd = nv.first;
 
            for (auto& rv : nv.second) {
                const string& regulation = rv.first;
                auto& tradeDataMap = rv.second;
 
                // Remove (or modify) trades with incomplete Schedule data
                set<string> tradesToRemove;
                for (auto& td : tradeDataMap) {
                    if (td.second.incomplete()) {
                        auto subFields = map<string, string>({{"tradeId", td.first}});
                        // If missing PV, assume PV = 0
                        if (td.second.missingPVData()) {
                            td.second.presentValue = 0.0;
                            td.second.presentValueUsd = 0.0;
                            td.second.presentValueCcy = td.second.notionalCcy;
                        }
                        // If missing Notional, do not process the trade
                        if (td.second.missingNotionalData()) {
                            ore::analytics::StructuredAnalyticsWarningMessage(
                                "IMSchedule", "Incomplete CRIF trade data",
                                "Missing Notional data. The trade will not be processed.", subFields)
                                .log();
                            tradesToRemove.insert(td.first);
                        }
                    }
                }
 
                for (const string& tid : tradesToRemove) {
                    tradeDataMap.erase(tid);
                    tradeIds_.at(side).at(nsd).at(regulation).erase(tid);
                }
 
                // Calculate Schedule data for each trade data obj
                for (auto& td : tradeDataMap) {
                    IMScheduleTradeData& tradeData = td.second;
 
                    // Calculate gross IM for each IM Schedule trade
                    tradeData.maturity = dayCounter.yearFraction(today, tradeData.endDate);
                    tradeData.label = label(tradeData.productClass, tradeData.maturity);
                    tradeData.labelString = labelString(tradeData.label);
                    tradeData.multiplier = multiplier(tradeData.label);
                    tradeData.grossMarginUsd = tradeData.multiplier * tradeData.notionalUsd;
 
                    // Convert some trade data values into calculation currency
                    const Real usdSpot = calculationCcy_ != "USD" ? market_->fxRate(calculationCcy_ + "USD")->value() : 1.0;
                    tradeData.notionalCalc = tradeData.notionalUsd / usdSpot;
                    tradeData.presentValueCalc = tradeData.presentValueUsd / usdSpot;
                    tradeData.grossMarginCalc = tradeData.grossMarginUsd / usdSpot;
                    if (side == SimmSide::Call)
                        tradeData.collectRegulations = regulation;
                    if (side == SimmSide::Post)
                        tradeData.postRegulations = regulation;
                }
            }
        }
    }
 
    // Some additional processing depending on the regulations applicable to each netting set
    for (auto& sv : nettingSetRegTradeData_) {
        const SimmSide& side = sv.first;
    
        for (auto& s : sv.second) {
            const NettingSetDetails& nettingDetails = s.first;
 
            // Where there is SEC and CFTC in the portfolio, we add the CFTC trades to SEC,
            // but still continue with CFTC calculations
            const bool hasCFTCGlobal = hasCFTC_.at(side).find(nettingDetails) != hasCFTC_.at(side).end();
            const bool hasSECGlobal = hasSEC_.at(side).find(nettingDetails) != hasSEC_.at(side).end();
            const bool hasCFTCLocal = s.second.count("CFTC") > 0;
            const bool hasSECLocal = s.second.count("SEC") > 0;
 
            if ((hasSECLocal && hasCFTCLocal) || (hasCFTCGlobal && hasSECGlobal)) {
                if (!hasSECLocal && !hasCFTCLocal)
                    continue;
 
                if (hasCFTCLocal) {
                    // At this point, we expect to have CFTC trade data at least for the netting set
                    const map<string, IMScheduleTradeData>& tradeDataMapCFTC = s.second.at("CFTC");
                    map<string, IMScheduleTradeData>& tradeDataMapSEC = s.second["SEC"];
                    for (const auto& kv : tradeDataMapCFTC) {
                        // Only add CFTC records to SEC if the record was not already in SEC,
                        // i.e. we skip over CRIF records with regulations specified as e.g. "..., CFTC, SEC, ..."
                        if (tradeDataMapSEC.find(kv.first) == tradeDataMapSEC.end()) {
                            tradeDataMapSEC[kv.first] = kv.second;
                        }
                    }
                }
            }
 
            // If netting set has "Unspecified" plus other regulations, the "Unspecified" sensis are to be excluded.
            // If netting set only has "Unspecified", then no regulations were ever specified, so all trades are
            // included.
            if (s.second.count("Unspecified") > 0 && s.second.size() > 1)
                s.second.erase("Unspecified");
        }
    }
 
    // Calculate the higher level margins
    LOG("IMScheduleCalculator: Populating higher level results")
    for (const auto& sv : nettingSetRegTradeData_) {
        const SimmSide side = sv.first;
 
        for (const auto& nv : sv.second) {
            const NettingSetDetails& nsd = nv.first;
 
            for (const auto& rv : nv.second) {
                const string& regulation = rv.first;
                populateResults(nsd, regulation, side);
            }
        }
    }
 
    if (determineWinningRegulations) {
        LOG("IMScheduleCalculator: Determining winning regulations");
 
        // Determine winning call and post regulations
        for (const auto& sv : imScheduleResults_) {
            const SimmSide side = sv.first;
 
            // Determine winning regulation for each netting set
            // Collect margin amounts and determine the highest margin amount
            for (const auto& nv : sv.second) {
                const NettingSetDetails& nsd = nv.first;
                Real winningMargin = std::numeric_limits<Real>::min();
                map<string, Real> nettingSetMargins;
                vector<Real> margins;
 
                for (const auto& rv : nv.second) {
                    const string& regulation = rv.first;
                    const IMScheduleResults& schResult = rv.second;
                    const Real& im = schResult.get(ProductClass::All).scheduleIM;
 
                    nettingSetMargins[regulation] = im;
                    if (im > winningMargin)
                        winningMargin = im;
                }
 
                // Determine winning regulations, i.e. regulations under which we find the highest margin amount
                vector<string> winningRegulations;
                for (const auto& kv : nettingSetMargins) {
                    if (close_enough(kv.second, winningMargin))
                        winningRegulations.push_back(kv.first);
                }
 
                // In the case of multiple winning regulations, pick one based on the priority in the list
                //const Regulation winningRegulation = getWinningRegulation(winningRegulations);
                string winningRegulation = winningRegulations.size() > 1
                                               ? to_string(getWinningRegulation(winningRegulations))
                                               : winningRegulations.at(0);
 
                // Populate internal list of winning regulators
                winningRegulations_[side][nsd] = ore::data::to_string(winningRegulation);
            }
        }
 
        populateFinalResults();
    }
}

Here is the call graph for this function:

Member Function Documentation

◆ finalTradeIds()

const std::map< SimmSide, std::set< std::string > > finalTradeIds ( ) const

Give back the set of portfolio IDs and trade IDs for which we have IM results.

Definition at line 121 of file imschedulecalculator.hpp.

121{ return finalTradeIds_; }

ore::analytics::IMScheduleCalculator::finalTradeIds_

std::map< SimmSide, set< string > > finalTradeIds_

Definition: imschedulecalculator.hpp:191

◆ winningRegulations() [1/3]

const string & winningRegulations	(	const SimmSide &	side,
		const ore::data::NettingSetDetails &	nettingSetDetails
	)		const

Return the winning regulation for each portfolioId.

Definition at line 271 of file imschedulecalculator.cpp.

                                                                                                         {
    const auto& subWinningRegs = winningRegulations(side);
    QL_REQUIRE(subWinningRegs.find(nettingSetDetails) != subWinningRegs.end(),
               "IMScheduleCalculator::winningRegulations(): Could not find netting set in the list of "
                   << side << " schedule IM winning regulations: " << nettingSetDetails);
    return subWinningRegs.at(nettingSetDetails);
}

Here is the call graph for this function:

◆ winningRegulations() [2/3]

const map< NettingSetDetails, string > & winningRegulations ( const SimmSide & side ) const

Definition at line 280 of file imschedulecalculator.cpp.

                                                                                                         {
    QL_REQUIRE(winningRegulations_.find(side) != winningRegulations_.end(),
               "IMScheduleCalculator::winningRegulations(): Could not find list of"
                   << side << " schedule IM winning regulations");
    return winningRegulations_.at(side);
}

◆ winningRegulations() [3/3]

const map< SimmConfiguration::SimmSide, map< NettingSetDetails, string > > & winningRegulations ( ) const

Definition at line 288 of file imschedulecalculator.cpp.

                                               {
    return winningRegulations_;
}

Here is the caller graph for this function:

◆ imScheduleSummaryResults() [1/3]

const map< string, IMScheduleResults > & imScheduleSummaryResults	(	const SimmSide &	side,
		const ore::data::NettingSetDetails &	nsd
	)		const

Give back the IM Schedule results container for the given portfolioId and IM side.

Definition at line 292 of file imschedulecalculator.cpp.

                                                                                                                                             {
    const auto& subResults = imScheduleSummaryResults(side);
    QL_REQUIRE(subResults.find(nsd) != subResults.end(),
               "IMScheduleCalculator::imScheduleSummaryResults(): Could not find netting set in the "
                   << side << " IM schedule results: " << nsd);
    return subResults.at(nsd);
}

Here is the call graph for this function:

◆ imScheduleSummaryResults() [2/3]

const map< NettingSetDetails, map< string, IMScheduleResults > > & imScheduleSummaryResults ( const SimmSide & side ) const

Definition at line 300 of file imschedulecalculator.cpp.

                                                                                                                                       {
    QL_REQUIRE(imScheduleResults_.find(side) != imScheduleResults_.end(),
               "IMScheduleCalculator::imScheduleSummaryResults(): Could not find " << side
                                                                                   << " IM in the IM Schedule results");
    return imScheduleResults_.at(side);
}

◆ imScheduleSummaryResults() [3/3]

const map< SimmConfiguration::SimmSide, map< NettingSetDetails, map< string, IMScheduleResults > > > & imScheduleSummaryResults ( ) const

Definition at line 308 of file imschedulecalculator.cpp.

                                                     {
    return imScheduleResults_;
};

Here is the caller graph for this function:

◆ finalImScheduleSummaryResults() [1/3]

const pair< string, IMScheduleResults > & finalImScheduleSummaryResults	(	const SimmSide &	side,
		const ore::data::NettingSetDetails &	nsd
	)		const

Definition at line 312 of file imschedulecalculator.cpp.

                                                                                                                               {
    const auto& subResults = finalImScheduleSummaryResults(side);
    QL_REQUIRE(subResults.find(nsd) != subResults.end(),
               "IMScheduleCalculator::finalImScheduleSummaryResults(): Could not find netting set in the final IM Schedule "
                   << side << " results: " << nsd);
    return subResults.at(nsd);
}

Here is the call graph for this function:

◆ finalImScheduleSummaryResults() [2/3]

const map< NettingSetDetails, pair< string, IMScheduleResults > > & finalImScheduleSummaryResults ( const SimmSide & side ) const

Definition at line 321 of file imschedulecalculator.cpp.

                                                                                                                                             {
    QL_REQUIRE(finalImScheduleResults_.find(side) != finalImScheduleResults_.end(),
               "IMScheduleCalculator::finalImScheduleSummaryResults(): Could not find "
                   << side << " IM in the final IM Schedule results");
    return finalImScheduleResults_.at(side);
}

◆ finalImScheduleSummaryResults() [3/3]

const std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::pair< std::string, IMScheduleResults > > > & finalImScheduleSummaryResults ( ) const

Definition at line 138 of file imschedulecalculator.hpp.

                                          {
        return finalImScheduleResults_;
    };

Here is the caller graph for this function:

◆ imScheduleTradeResults() [1/2]

const vector< IMScheduleCalculator::IMScheduleTradeData > & imScheduleTradeResults ( const std::string & tradeId ) const

Give back the IM Schedule results container for the given tradeId and IM side.

Definition at line 328 of file imschedulecalculator.cpp.

                                                                                                                               {
    QL_REQUIRE(finalTradeData_.find(tradeId) != finalTradeData_.end(),
               "IMScheduleCalculator::imScheduleTradeResults(): Could not find results for trade: " << tradeId);
    return finalTradeData_.at(tradeId);
}

◆ imScheduleTradeResults() [2/2]

const map< string, vector< IMScheduleCalculator::IMScheduleTradeData > > & imScheduleTradeResults ( ) const

Definition at line 334 of file imschedulecalculator.cpp.

                                                                                                                       {
    return finalTradeData_;
}

◆ finalImScheduleTradeResults() [1/2]

const IMScheduleTradeData & finalImScheduleTradeResults ( const std::string & tradeId ) const

◆ finalImScheduleTradeResults() [2/2]

const std::map< std::string, IMScheduleTradeData > & finalImScheduleTradeResults ( ) const

◆ calculationCurrency()

const std::string & calculationCurrency ( ) const

Return the calculator's calculation currency.

Definition at line 150 of file imschedulecalculator.hpp.

150{ return calculationCcy_; }

◆ label()

const IMScheduleLabel label	(	const ProductClass &	productClass,
		const QuantLib::Real &	maturity
	)

static

Definition at line 338 of file imschedulecalculator.cpp.

                                                                                              {
    if (pc == ProductClass::Credit) {
        if (maturity >= 0.0 && maturity < 2.0) {
            return IMScheduleLabel::Credit2;
        } else if (maturity < 5.0) {
            return IMScheduleLabel::Credit5;
        } else {
            return IMScheduleLabel::Credit100;
        }
 
    } else if (pc == ProductClass::Commodity) {
        return IMScheduleLabel::Commodity;
 
    } else if (pc == ProductClass::Equity) {
        return IMScheduleLabel::Equity;
 
    } else if (pc == ProductClass::FX) {
        return IMScheduleLabel::FX;
 
    } else if (pc == ProductClass::Rates) {
        if (maturity >= 0.0 && maturity < 2.0) {
            return IMScheduleLabel::Rates2;
        } else if (maturity < 5.0) {
            return IMScheduleLabel::Rates5;
        } else {
            return IMScheduleLabel::Rates100;
        }
 
    } else if (pc == ProductClass::Other) {
        return IMScheduleLabel::Other;
    } else {
        QL_FAIL("IMSchedule::label() Invalid product class " << pc);
    }
}

Here is the caller graph for this function:

◆ labelString()

const string labelString ( const IMScheduleLabel & label )

static

Definition at line 373 of file imschedulecalculator.cpp.

                                                                           {
    const map<IMScheduleLabel, string> labelStringMap_ = map<IMScheduleLabel, string>({
        {IMScheduleLabel::Credit2, "Credit 0-2 years"},
        {IMScheduleLabel::Credit5, "Credit 2-5 years"},
        {IMScheduleLabel::Credit100, "Credit 5+ years"},
        {IMScheduleLabel::Commodity, "Commodity"},
        {IMScheduleLabel::Equity, "Equity"},
        {IMScheduleLabel::FX, "FX"},
        {IMScheduleLabel::Rates2, "Interest Rate 0-2 years"},
        {IMScheduleLabel::Rates5, "Interest Rate 2-5 years"},
        {IMScheduleLabel::Rates100, "Interest Rate 5+ years"},
        {IMScheduleLabel::Other, "Other"},
    });
 
    return labelStringMap_.at(label);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ populateFinalResults() [1/2]

void populateFinalResults ( const std::map< SimmSide, std::map< ore::data::NettingSetDetails, std::string > > & winningRegulations )

◆ multiplier()

QuantLib::Real multiplier ( const IMScheduleLabel & label )

private

Definition at line 220 of file imschedulecalculator.hpp.

220{ return multiplierMap_[label]; }

ore::analytics::IMScheduleCalculator::multiplierMap_

std::map< IMScheduleLabel, QuantLib::Real > multiplierMap_

Definition: imschedulecalculator.hpp:205

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collectTradeData()

void collectTradeData	(	const CrifRecord &	cr,
		const bool	enforceIMRegulations
	)

private

Collect trade data as defined by the CRIF records.

Definition at line 390 of file imschedulecalculator.cpp.

                                                                                                 {
 
    DLOG("Processing CRIF record for IMSchedule calculation: trade ID \'"
         << cr.tradeId << "\', portfolio [" << cr.nettingSetDetails << "], product class " << cr.productClass
         << ", risk type " << cr.riskType << ", end date " << cr.endDate);
    QL_REQUIRE(cr.riskType == RiskType::PV || cr.riskType == RiskType::Notional,
               "Unexpected risk type found in CRIF " << cr.riskType << " for trade ID " << cr.tradeId);
 
    for (const auto& side : {SimmSide::Call, SimmSide::Post}) {
        const NettingSetDetails& nettingSetDetails = cr.nettingSetDetails;
 
        bool collectRegsIsEmpty = false;
        bool postRegsIsEmpty = false;
        if (collectRegsIsEmpty_.find(cr.nettingSetDetails) != collectRegsIsEmpty_.end())
            collectRegsIsEmpty = collectRegsIsEmpty_.at(cr.nettingSetDetails);
        if (postRegsIsEmpty_.find(cr.nettingSetDetails) != postRegsIsEmpty_.end())
            postRegsIsEmpty = postRegsIsEmpty_.at(cr.nettingSetDetails);
 
        string regsString;
        if (enforceIMRegulations)
            regsString = side == SimmSide::Call ? cr.collectRegulations : cr.postRegulations;
        set<string> regs = parseRegulationString(regsString);
 
        for (const string& r : regs) {
            if (r == "Unspecified" && enforceIMRegulations && !(collectRegsIsEmpty && postRegsIsEmpty)) {
                continue;
            } else if (r != "Excluded") {
                // Keep a record of trade IDs for each regulation
                tradeIds_[side][nettingSetDetails][r].insert(cr.tradeId);
 
                auto& tradeDataMap = nettingSetRegTradeData_[side][nettingSetDetails][r];
                auto it = tradeDataMap.find(cr.tradeId);
                if (it != tradeDataMap.end()) {
                    IMScheduleTradeData& tradeData = it->second;
 
                    QL_REQUIRE(cr.productClass == tradeData.productClass, "Product class is not matching for trade ID "
                                                                              << cr.tradeId << ": " << cr.productClass
                                                                              << " and " << tradeData.productClass);
                    QuantLib::Date incomingDate = parseDate(cr.endDate);
                    QL_REQUIRE(incomingDate == tradeData.endDate, "End date is not matching for trade ID "
                                                                      << cr.tradeId << ": " << incomingDate << " and "
                                                                      << tradeData.endDate);
                    if (cr.riskType == RiskType::PV) {
                        QL_REQUIRE(tradeData.missingPVData(), "Adding PV data for trade that already has PV data, i.e. "
                                                              "multiple PV records found for the same trade: "
                                                                  << tradeData.tradeId);
                        tradeData.presentValue = cr.amount;
                        tradeData.presentValueUsd = cr.amountUsd;
                        tradeData.presentValueCcy = cr.amountCurrency;
                    } else {
                        QL_REQUIRE(tradeData.missingNotionalData(),
                                   "Adding Notional data for trade that already has PV data, i.e. "
                                   "multiple Notional records found for the same trade: "
                                       << tradeData.tradeId);
                        tradeData.notional = cr.amount;
                        tradeData.notionalUsd = cr.amountUsd;
                        tradeData.notionalCcy = cr.amountCurrency;
                    }
                } else {
                    const string collectRegs = side == SimmSide::Call ? cr.collectRegulations : "";
                    const string postRegs = side == SimmSide::Post ? cr.postRegulations : "";
                    tradeDataMap.insert(
                        {cr.tradeId, IMScheduleTradeData(cr.tradeId, cr.nettingSetDetails, cr.riskType, cr.productClass,
                                                         cr.amount, cr.amountCurrency, cr.amountUsd,
                                                         parseDate(cr.endDate), calculationCcy_, collectRegs, postRegs)});
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ populateResults()

void populateResults	(	const ore::data::NettingSetDetails &	nsd,
		const string &	regulation,
		const SimmSide &	side
	)

private

Populate the results structure with the higher level results after the IMs have been calculated at the (product class, maturity) level for each portfolio

Definition at line 461 of file imschedulecalculator.cpp.

                                                                 {
 
    LOG("IMScheduleCalculator: Populating " << side << " IM for netting set [" << nettingSetDetails
                                            << "] under regulation " << regulation);
 
 
    const auto& regTradeData = nettingSetRegTradeData_.at(side).at(nettingSetDetails).at(regulation);
 
    Real grossMarginCalc = 0;
    Real grossRCCalc = 0;
    Real presentValueCalc = 0;
 
    // Populate results at the product class level
    for (const auto& td : regTradeData) {
        const IMScheduleTradeData& tradeData = td.second;
        add(side, nettingSetDetails, regulation, tradeData.productClass, calculationCcy_, tradeData.grossMarginCalc);
        
        // Sum up trade details to obtain netting set level values:
        // - Gross margin, gross RC, net RC, PVs
        grossMarginCalc += tradeData.grossMarginCalc;
        grossRCCalc +=
            side == SimmSide::Call ? max(0.0, tradeData.presentValueCalc) : min(0.0, tradeData.presentValueCalc);
 
        presentValueCalc += tradeData.presentValueCalc;
    }
 
    // Calculate other amounts at the nettingSet-regulator level
 
    // Net replacement cost
    Real netRCCalc = side == SimmSide::Call ? max(0.0, presentValueCalc) : min(0.0, presentValueCalc);
 
    // Net-to-gross ratio
    Real netToGrossCalc = close_enough(grossRCCalc, 0.0) ? 1.0 : netRCCalc / grossRCCalc;
 
    // Schedule IM
    Real scheduleMarginCalc = grossMarginCalc * (0.4 + 0.6 * netToGrossCalc);
 
    // Populate higher level results
    imScheduleResults_.at(side)
        .at(nettingSetDetails)
        .at(regulation)
        .add(ProductClass::All, calculationCcy_, grossMarginCalc, grossRCCalc, netRCCalc, netToGrossCalc,
             scheduleMarginCalc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ populateFinalResults() [2/2]

void populateFinalResults ( )

private

Populate final (i.e. winning regulators') using own list of winning regulators, which were determined solely by the IMSchedule results (i.e. not including any external SIMM results)

Definition at line 572 of file imschedulecalculator.cpp.

                                                {
    populateFinalResults(winningRegulations_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add()

void add	(	const SimmSide &	side,
		const ore::data::NettingSetDetails &	nsd,
		const std::string &	regulation,
		const CrifRecord::ProductClass &	pc,
		const std::string &	ccy,
		const QuantLib::Real &	grossIM,
		const QuantLib::Real &	grossRC = `QuantLib::Null<QuantLib::Real>()`,
		const QuantLib::Real &	netRC = `QuantLib::Null<QuantLib::Real>()`,
		const QuantLib::Real &	ngr = `QuantLib::Null<QuantLib::Real>()`,
		const QuantLib::Real &	scheduleIM = `QuantLib::Null<QuantLib::Real>()`
	)

private

Add a margin result to either call or post results container depending on the SimmSide parameter.

Definition at line 576 of file imschedulecalculator.cpp.

                                                                                           {
    
    QuantLib::Real netToGrossRatio = ngr != Null<Real>() && close_enough(ngr, 0.0) ? 0.0 : ngr;
    imScheduleResults_[side][nsd][regulation].add(pc, calcCcy, grossIM, grossRC, netRC, netToGrossRatio, scheduleIM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ crif_

ore::analytics::Crif crif_

private

The net sensitivities used in the calculation.

Definition at line 160 of file imschedulecalculator.hpp.

◆ calculationCcy_

std::string calculationCcy_

private

The SIMM calculation currency i.e. the currency of the SIMM results.

Definition at line 163 of file imschedulecalculator.hpp.

◆ market_

QuantLib::ext::shared_ptr<ore::data::Market> market_

private

Market data for FX rates to use for converting amounts to USD.

Definition at line 166 of file imschedulecalculator.hpp.

◆ quiet_

bool quiet_

private

If true, no logging is written out.

Definition at line 169 of file imschedulecalculator.hpp.

◆ hasSEC_

std::map<SimmSide, std::set<NettingSetDetails> > hasSEC_

private

Definition at line 171 of file imschedulecalculator.hpp.

◆ hasCFTC_

std::map<SimmSide, std::set<NettingSetDetails> > hasCFTC_

private

Definition at line 171 of file imschedulecalculator.hpp.

◆ collectRegsIsEmpty_

std::map<ore::data::NettingSetDetails, bool> collectRegsIsEmpty_

private

For each netting set, whether all CRIF records' collect regulations are empty.

Definition at line 174 of file imschedulecalculator.hpp.

◆ postRegsIsEmpty_

std::map<ore::data::NettingSetDetails, bool> postRegsIsEmpty_

private

For each netting set, whether all CRIF records' post regulations are empty.

Definition at line 177 of file imschedulecalculator.hpp.

◆ imScheduleResults_

std::map<SimmSide, std::map<ore::data::NettingSetDetails, std::map<std::string, IMScheduleResults> > > imScheduleResults_

private

Containers, one for call and post, with an IMScheduleResults object for each regulation under each portfolio ID.

Definition at line 181 of file imschedulecalculator.hpp.

◆ finalImScheduleResults_

std::map<SimmSide, std::map<ore::data::NettingSetDetails, std::pair<std::string, IMScheduleResults> > > finalImScheduleResults_

private

Containers, one for call and post, with an IMScheduleResults object for each portfolio ID.

Definition at line 185 of file imschedulecalculator.hpp.

◆ tradeIds_

std::map<SimmSide, std::map<ore::data::NettingSetDetails, std::map<std::string, set<string> > > > tradeIds_

private

Container for keeping track of what trade IDs belong to each regulation.

Definition at line 189 of file imschedulecalculator.hpp.

◆ finalTradeIds_

std::map<SimmSide, set<string> > finalTradeIds_

private

Definition at line 191 of file imschedulecalculator.hpp.

◆ winningRegulations_

std::map<SimmSide, std::map<ore::data::NettingSetDetails, std::string> > winningRegulations_

private

Regulation with highest IM for each given netting set.

Definition at line 195 of file imschedulecalculator.hpp.

◆ finalTradeData_

std::map<std::string, std::vector<IMScheduleTradeData> > finalTradeData_

private

Container for trade data collected from CRIF report trade ID trade data

Definition at line 199 of file imschedulecalculator.hpp.

◆ nettingSetRegTradeData_

std::map<SimmSide, std::map<ore::data::NettingSetDetails, std::map<std::string, std::map<std::string, IMScheduleTradeData> > > > nettingSetRegTradeData_

private

Container for trade data, taking into account regulations applicable to each netting set.

Definition at line 203 of file imschedulecalculator.hpp.

◆ multiplierMap_

std::map<IMScheduleLabel, QuantLib::Real> multiplierMap_

private

Initial value:

= std::map<IMScheduleLabel, QuantLib::Real>({
        
        {IMScheduleLabel::Credit2,      0.02},
        {IMScheduleLabel::Credit5,      0.05},
        {IMScheduleLabel::Credit100,    0.10},
        {IMScheduleLabel::Commodity,    0.15},
        {IMScheduleLabel::Equity,       0.15},
        {IMScheduleLabel::FX,           0.06},
        {IMScheduleLabel::Rates2,       0.01},
        {IMScheduleLabel::Rates5,       0.02},
        {IMScheduleLabel::Rates100,     0.04},
        {IMScheduleLabel::Other,        0.15},
        
    })

Definition at line 205 of file imschedulecalculator.hpp.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ProductClass

◆ RiskType

◆ Regulation

◆ SimmSide

Constructor & Destructor Documentation

◆ IMScheduleCalculator()

Member Function Documentation

◆ finalTradeIds()

◆ winningRegulations() [1/3]

◆ winningRegulations() [2/3]

◆ winningRegulations() [3/3]

◆ imScheduleSummaryResults() [1/3]

◆ imScheduleSummaryResults() [2/3]

◆ imScheduleSummaryResults() [3/3]

◆ finalImScheduleSummaryResults() [1/3]

◆ finalImScheduleSummaryResults() [2/3]

◆ finalImScheduleSummaryResults() [3/3]

◆ imScheduleTradeResults() [1/2]

◆ imScheduleTradeResults() [2/2]

◆ finalImScheduleTradeResults() [1/2]

◆ finalImScheduleTradeResults() [2/2]

◆ calculationCurrency()

◆ label()

◆ labelString()

◆ populateFinalResults() [1/2]

◆ multiplier()

◆ collectTradeData()

◆ populateResults()

◆ populateFinalResults() [2/2]

◆ add()

Member Data Documentation

◆ crif_

◆ calculationCcy_

◆ market_

◆ quiet_

◆ hasSEC_

◆ hasCFTC_

◆ collectRegsIsEmpty_

◆ postRegsIsEmpty_

◆ imScheduleResults_

◆ finalImScheduleResults_

◆ tradeIds_

◆ finalTradeIds_

◆ winningRegulations_

◆ finalTradeData_

◆ nettingSetRegTradeData_

◆ multiplierMap_