DynamicInitialMarginCalculator Class Reference

Dynamic Initial Margin Calculator base class. More...

#include <orea/aggregation/dimcalculator.hpp>

Inheritance diagram for DynamicInitialMarginCalculator:

Collaboration diagram for DynamicInitialMarginCalculator:

Public Member Functions
	DynamicInitialMarginCalculator (const QuantLib::ext::shared_ptr< InputParameters > &inputs, const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< NPVCube > &cube, const QuantLib::ext::shared_ptr< CubeInterpretation > &cubeInterpretation, const QuantLib::ext::shared_ptr< AggregationScenarioData > &scenarioData, Real quantile=0.99, Size horizonCalendarDays=14, const std::map< std::string, Real > &currentIM=std::map< std::string, Real >())
virtual	~DynamicInitialMarginCalculator ()
virtual map< string, Real >	unscaledCurrentDIM ()=0
	Model implied t0 DIM by netting set, does not need a call to build() before. More...
const map< string, Real > &	currentIM () const
	t0 IM by netting set, as provided as an arguments More...
virtual void	build ()=0
	Compute dynamic initial margin along all paths and fill result structures. More...
virtual void	exportDimEvolution (ore::data::Report &dimEvolutionReport) const
	DIM evolution report. More...
const QuantLib::ext::shared_ptr< NPVCube > &	dimCube ()
	DIM by nettingSet, date, sample returned as a regular NPV cube. More...
const vector< vector< Real > > &	dynamicIM (const string &nettingSet)
	DIM matrix by date and sample index for the specified netting set. More...
const vector< vector< Real > > &	cashFlow (const string &nettingSet)
	Cash flow matrix by date and sample index for the specified netting set. More...
const vector< Real > &	expectedIM (const string &nettingSet)
	Expected DIM vector by date for the specified netting set. More...
const std::map< std::string, Real > &	getInitialMarginScaling ()
	Get the implied netting set specific scaling factors. More...

Protected Attributes
QuantLib::ext::shared_ptr< InputParameters >	inputs_
QuantLib::ext::shared_ptr< Portfolio >	portfolio_
QuantLib::ext::shared_ptr< NPVCube >	cube_
QuantLib::ext::shared_ptr< NPVCube >	dimCube_
QuantLib::ext::shared_ptr< CubeInterpretation >	cubeInterpretation_
QuantLib::ext::shared_ptr< AggregationScenarioData >	scenarioData_
Real	quantile_
Size	horizonCalendarDays_
map< string, Real >	currentIM_
bool	cubeIsRegular_
Size	datesLoopSize_
std::set< string >	nettingSetIds_
map< string, Real >	nettingSetScaling_
map< string, vector< vector< Real > > >	nettingSetNPV_
map< string, vector< vector< Real > > >	nettingSetCloseOutNPV_
map< string, vector< vector< Real > > >	nettingSetFLOW_
map< string, vector< vector< Real > > >	nettingSetDeltaNPV_
map< string, vector< vector< Real > > >	nettingSetDIM_
map< string, vector< Real > >	nettingSetExpectedDIM_

Detailed Description

Dynamic Initial Margin Calculator base class.

Derived classes implement a constructor with the relevant additional input data and a build function that performs the DIM calculations for all netting sets and along all paths.

Definition at line 53 of file dimcalculator.hpp.

Constructor & Destructor Documentation

DynamicInitialMarginCalculator()

DynamicInitialMarginCalculator	(	const QuantLib::ext::shared_ptr< InputParameters > &	inputs,
		const QuantLib::ext::shared_ptr< Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< NPVCube > &	cube,
		const QuantLib::ext::shared_ptr< CubeInterpretation > &	cubeInterpretation,
		const QuantLib::ext::shared_ptr< AggregationScenarioData > &	scenarioData,
		Real	quantile = 0.99,
		Size	horizonCalendarDays = 14,
		const std::map< std::string, Real > &	currentIM = std::map<std::string, Real>()
	)

Parameters

inputs	Global input parameters
portfolio	Driving portfolio consistent with the cube below
cube	NPV cube resulting from the Monte Carlo simulation loop
cubeInterpretation	Interpretation of the cube, regular NPV, MPoR grid etc
scenarioData	Additional output of the MC simulation loop with numeraires, index fixings, FX spots etc
quantile	VaR quantile, e.g. 0.99 for 99%
horizonCalendarDays	VaR holding period in calendar days
currentIM	Actual t0 IM by netting set used to scale the DIM evolution, no scaling if the argument is omitted

Definition at line 48 of file dimcalculator.cpp.

    : inputs_(inputs), portfolio_(portfolio), cube_(cube), cubeInterpretation_(cubeInterpretation), scenarioData_(scenarioData),
      quantile_(quantile), horizonCalendarDays_(horizonCalendarDays), currentIM_(currentIM) {
 
    QL_REQUIRE(portfolio_, "portfolio is null");
    QL_REQUIRE(cube_, "cube is null");
    QL_REQUIRE(cubeInterpretation_, "cube interpretation is null");
    QL_REQUIRE(scenarioData_, "aggregation scenario data is null");
 
    cubeIsRegular_ = !cubeInterpretation_->withCloseOutLag();
    datesLoopSize_ = cubeIsRegular_ ? cube_->dates().size() - 1 : cube_->dates().size();
 
    Size dates = cube_->dates().size();
    Size samples = cube_->samples();
 
    if (!cubeInterpretation_->storeFlows()) {
        WLOG("cube holds no mpor flows, will assume no flows in the dim calculation");
    }
 
    // initialise aggregate NPV and Flow by date and scenario
    set<string> nettingSets;
    size_t i = 0;
    for (auto tradeIt = portfolio_->trades().begin(); tradeIt != portfolio_->trades().end(); ++tradeIt, ++i) {
        auto trade = tradeIt->second;
        string tradeId = tradeIt->first;
        string nettingSetId = trade->envelope().nettingSetId();
        if (nettingSets.find(nettingSetId) == nettingSets.end()) {
            nettingSets.insert(nettingSetId);
            nettingSetNPV_[nettingSetId] = vector<vector<Real>>(dates, vector<Real>(samples, 0.0));
            nettingSetCloseOutNPV_[nettingSetId] = vector<vector<Real>>(dates, vector<Real>(samples, 0.0));
            nettingSetFLOW_[nettingSetId] = vector<vector<Real>>(dates, vector<Real>(samples, 0.0));
            nettingSetDeltaNPV_[nettingSetId] = vector<vector<Real>>(dates, vector<Real>(samples, 0.0));
            nettingSetDIM_[nettingSetId] = vector<vector<Real>>(dates, vector<Real>(samples, 0.0));
            nettingSetExpectedDIM_[nettingSetId] = vector<Real>(dates, 0.0);
        }
        for (Size j = 0; j < datesLoopSize_; ++j) {
            for (Size k = 0; k < samples; ++k) {
                Real defaultNpv = cubeInterpretation_->getDefaultNpv(cube_, i, j, k);
                Real closeOutNpv = cubeInterpretation_->getCloseOutNpv(cube_, i, j, k);
                Real mporFlow =
                    cubeInterpretation_->storeFlows() ? cubeInterpretation_->getMporFlows(cube_, i, j, k) : 0.0;
                nettingSetNPV_[nettingSetId][j][k] += defaultNpv;
                nettingSetCloseOutNPV_[nettingSetId][j][k] += closeOutNpv;
                nettingSetFLOW_[nettingSetId][j][k] += mporFlow;
            }
        }
    }
 
    
    nettingSetIds_ = std::move(nettingSets);
 
    dimCube_ = QuantLib::ext::make_shared<SinglePrecisionInMemoryCube>(cube_->asof(), nettingSetIds_, cube_->dates(),
                                                               cube_->samples());
}

~DynamicInitialMarginCalculator()

virtual ~DynamicInitialMarginCalculator ( )

virtual

Definition at line 73 of file dimcalculator.hpp.

{}

Member Function Documentation

unscaledCurrentDIM()

virtual map< string, Real > unscaledCurrentDIM ( )

pure virtual

Model implied t0 DIM by netting set, does not need a call to build() before.

Implemented in FlatDynamicInitialMarginCalculator, and RegressionDynamicInitialMarginCalculator.

currentIM()

const map< string, Real > & currentIM

(

)

const

t0 IM by netting set, as provided as an arguments

Definition at line 79 of file dimcalculator.hpp.

{ return currentIM_; }

Here is the caller graph for this function:

build()

virtual void build ( )

pure virtual

Compute dynamic initial margin along all paths and fill result structures.

Implemented in FlatDynamicInitialMarginCalculator, and RegressionDynamicInitialMarginCalculator.

exportDimEvolution()

void exportDimEvolution ( ore::data::Report &  dimEvolutionReport ) const

virtual

DIM evolution report.

Reimplemented in FlatDynamicInitialMarginCalculator, and RegressionDynamicInitialMarginCalculator.

Definition at line 129 of file dimcalculator.cpp.

                                                                                               {
 
    Size samples = dimCube_->samples();
    Size stopDatesLoop = datesLoopSize_;
    Date asof = cube_->asof();
 
    dimEvolutionReport.addColumn("TimeStep", Size())
        .addColumn("Date", Date())
        .addColumn("DaysInPeriod", Size())
        .addColumn("AverageDIM", Real(), 6)
        .addColumn("AverageFLOW", Real(), 6)
        .addColumn("NettingSet", string())
        .addColumn("Time", Real(), 6);
 
    for (auto [nettingSet, _] : dimCube_->idsAndIndexes()) {
 
        LOG("Export DIM evolution for netting set " << nettingSet);
        for (Size i = 0; i < stopDatesLoop; ++i) {
            Real expectedFlow = 0.0;
            for (Size j = 0; j < samples; ++j) {
                expectedFlow += nettingSetFLOW_.find(nettingSet)->second[i][j] / samples;
            }
 
            Date defaultDate = dimCube_->dates()[i];
        Time t = ActualActual(ActualActual::ISDA).yearFraction(asof, defaultDate);
            Size days = cubeInterpretation_->getMporCalendarDays(dimCube_, i);
            dimEvolutionReport.next()
                .add(i)
                .add(defaultDate)
                .add(days)
                .add(nettingSetExpectedDIM_.find(nettingSet)->second[i])
                .add(expectedFlow)
                .add(nettingSet)
            .add(t);
        }
    }
    dimEvolutionReport.end();
    LOG("Exporting expected DIM through time done");
}

Here is the call graph for this function:

dimCube()

const QuantLib::ext::shared_ptr< NPVCube > & dimCube

(

)

DIM by nettingSet, date, sample returned as a regular NPV cube.

Definition at line 88 of file dimcalculator.hpp.

{ return dimCube_; }

dynamicIM()

const vector< vector< Real > > & dynamicIM

(

const string &

nettingSet

)

DIM matrix by date and sample index for the specified netting set.

Definition at line 108 of file dimcalculator.cpp.

                                                                                                 {
    if (nettingSetDIM_.find(nettingSet) != nettingSetDIM_.end())
        return nettingSetDIM_[nettingSet];
    else
        QL_FAIL("netting set " << nettingSet << " not found in DIM results");
}

cashFlow()

const vector< vector< Real > > & cashFlow

(

const string &

nettingSet

)

Cash flow matrix by date and sample index for the specified netting set.

Definition at line 122 of file dimcalculator.cpp.

                                                                                                {
    if (nettingSetFLOW_.find(nettingSet) != nettingSetFLOW_.end())
        return nettingSetFLOW_[nettingSet];
    else
        QL_FAIL("netting set " << nettingSet << " not found in DIM results");
}

expectedIM()

const vector< Real > & expectedIM

(

const string &

nettingSet

)

Expected DIM vector by date for the specified netting set.

Definition at line 115 of file dimcalculator.cpp.

                                                                                          {
    if (nettingSetExpectedDIM_.find(nettingSet) != nettingSetExpectedDIM_.end())
        return nettingSetExpectedDIM_[nettingSet];
    else
        QL_FAIL("netting set " << nettingSet << " not found in expected DIM results");
}

getInitialMarginScaling()

const std::map< std::string, Real > & getInitialMarginScaling

(

)

Get the implied netting set specific scaling factors.

Definition at line 100 of file dimcalculator.hpp.

{ return nettingSetScaling_; }

Member Data Documentation

inputs_

QuantLib::ext::shared_ptr<InputParameters> inputs_

protected

Definition at line 103 of file dimcalculator.hpp.

portfolio_

QuantLib::ext::shared_ptr<Portfolio> portfolio_

protected

Definition at line 104 of file dimcalculator.hpp.

cube_

QuantLib::ext::shared_ptr<NPVCube> cube_

protected

Definition at line 105 of file dimcalculator.hpp.

dimCube_

QuantLib::ext::shared_ptr<NPVCube> dimCube_

protected

Definition at line 105 of file dimcalculator.hpp.

cubeInterpretation_

QuantLib::ext::shared_ptr<CubeInterpretation> cubeInterpretation_

protected

Definition at line 106 of file dimcalculator.hpp.

scenarioData_

QuantLib::ext::shared_ptr<AggregationScenarioData> scenarioData_

protected

Definition at line 107 of file dimcalculator.hpp.

quantile_

Real quantile_

protected

Definition at line 108 of file dimcalculator.hpp.

horizonCalendarDays_

Size horizonCalendarDays_

protected

Definition at line 109 of file dimcalculator.hpp.

currentIM_

map<string, Real> currentIM_

protected

Definition at line 110 of file dimcalculator.hpp.

cubeIsRegular_

bool cubeIsRegular_

protected

Definition at line 112 of file dimcalculator.hpp.

datesLoopSize_

Size datesLoopSize_

protected

Definition at line 113 of file dimcalculator.hpp.

nettingSetIds_

std::set<string> nettingSetIds_

protected

Definition at line 114 of file dimcalculator.hpp.

nettingSetScaling_

map<string, Real> nettingSetScaling_

protected

Definition at line 115 of file dimcalculator.hpp.

nettingSetNPV_

map<string, vector<vector<Real> > > nettingSetNPV_

protected

Definition at line 118 of file dimcalculator.hpp.

nettingSetCloseOutNPV_

map<string, vector<vector<Real> > > nettingSetCloseOutNPV_

protected

Definition at line 119 of file dimcalculator.hpp.

nettingSetFLOW_

map<string, vector<vector<Real> > > nettingSetFLOW_

protected

Definition at line 120 of file dimcalculator.hpp.

nettingSetDeltaNPV_

map<string, vector<vector<Real> > > nettingSetDeltaNPV_

protected

Definition at line 121 of file dimcalculator.hpp.

nettingSetDIM_

map<string, vector<vector<Real> > > nettingSetDIM_

protected

Definition at line 122 of file dimcalculator.hpp.

nettingSetExpectedDIM_

map<string, vector<Real> > nettingSetExpectedDIM_

protected

Definition at line 125 of file dimcalculator.hpp.