#include <orea/engine/marketriskbacktest.hpp>

Inheritance diagram for MarketRiskBacktest:

Collaboration diagram for MarketRiskBacktest:

Classes
struct	BacktestArgs

class	BacktestReports

struct	Data
	Used to pass information. More...

struct	SummaryResults
	Used to store results for writing rows in the summary report. More...

struct	VarBenchmark

Public Types
enum class	VarType { HistSim , HistSimTaylor , Parametric , Lch }
	VAR types used as a benchmark against which SIMM can be compared. More...

Public Member Functions
	MarketRiskBacktest (const std::string &calculationCurrency, const QuantLib::ext::shared_ptr< ore::data::Portfolio > &portfolio, const std::string &portfolioFilter, std::unique_ptr< BacktestArgs > btArgs, std::unique_ptr< SensiRunArgs > sensiArgs=nullptr, std::unique_ptr< FullRevalArgs > revalArgs=nullptr, std::unique_ptr< MultiThreadArgs > mtArgs=nullptr, const QuantLib::ext::shared_ptr< ore::analytics::HistoricalScenarioGenerator > &hisScenGen=nullptr, const bool breakdown=false, const bool requireTradePnl=false)

virtual	~MarketRiskBacktest ()

bool	disablesAll (const QuantLib::ext::shared_ptr< ore::analytics::ScenarioFilter > &filter) const override

virtual void	addPnlRow (const QuantLib::ext::shared_ptr< BacktestReports > &reports, QuantLib::Size scenarioIdx, bool isCall, const ore::analytics::RiskFactorKey &key_1, QuantLib::Real shift_1, QuantLib::Real delta, QuantLib::Real gamma, QuantLib::Real deltaPnl, QuantLib::Real gammaPnl, const ore::analytics::RiskFactorKey &key_2=ore::analytics::RiskFactorKey(), QuantLib::Real shift_2=0.0, const std::string &tradeId="", const std::string &currency="", QuantLib::Real fxSpot=1.0)
	Add a row to the P&L contribution report. More...

Public Member Functions inherited from MarketRiskReport
	MarketRiskReport (const std::string &calculationCurrency, const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const std::string &portfolioFilter, boost::optional< ore::data::TimePeriod > period, const QuantLib::ext::shared_ptr< HistoricalScenarioGenerator > &hisScenGen=nullptr, std::unique_ptr< SensiRunArgs > sensiArgs=nullptr, std::unique_ptr< FullRevalArgs > fullRevalArgs=nullptr, std::unique_ptr< MultiThreadArgs > multiThreadArgs=nullptr, const bool breakdown=false, const bool requireTradePnl=false)

virtual	~MarketRiskReport ()

virtual void	initialise ()

void	initSimMarket ()
	Method to init simMarket_ for multi-threaded ctors. More...

virtual void	calculate (const QuantLib::ext::shared_ptr< Reports > &report)

void	enableCubeWrite (const std::string &cubeDir, const std::string &cubeFilename)

Public Member Functions inherited from ProgressReporter
	ProgressReporter ()

void	registerProgressIndicator (const QuantLib::ext::shared_ptr< ProgressIndicator > &indicator)

void	unregisterProgressIndicator (const QuantLib::ext::shared_ptr< ProgressIndicator > &indicator)

void	unregisterAllProgressIndicators ()

void	updateProgress (const unsigned long progress, const unsigned long total, const std::string &detail="")

void	resetProgress ()

const std::set< QuantLib::ext::shared_ptr< ProgressIndicator > > &	progressIndicators () const

Protected Types
typedef std::map< VarType, std::pair< QuantLib::ext::shared_ptr< ore::analytics::VarCalculator >, QuantLib::Real > >	VarBenchmarks
	pointers to the VAR benchmarks More...

Protected Member Functions
void	initialise () override

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size > >	summaryColumns ()=0

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size, bool > >	detailColumns ()=0

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size > >	pnlColumns ()=0

virtual QuantLib::Real	callValue (const Data &data)=0

virtual QuantLib::Real	postValue (const Data &data)=0

virtual std::string	counterparty (const std::string &tradeId) const =0

virtual void	setUpBenchmarks ()=0

virtual void	reset (const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup) override

void	createReports (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports) override

virtual bool	runTradeDetail (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports) override

ore::data::TimePeriod	covariancePeriod () const override

void	addPnlCalculators (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports) override

void	handleSensiResults (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports, const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &tradeGroup) override

void	handleFullRevalResults (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports, const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &tradeGroup) override

virtual void	adjustFullRevalPnls (std::vector< QuantLib::Real > &pnls, std::vector< QuantLib::Real > &bmPnls, ore::analytics::TradePnLStore &tradePnls, const std::vector< QuantLib::Real > &foSensiPnls, const std::vector< QuantLib::Real > &bmFoSensiPnls, const ore::analytics::TradePnLStore &foTradePnls, const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup)

virtual void	addDetailRow (const QuantLib::ext::shared_ptr< BacktestReports > &reports, const Data &data, bool isCall, QuantLib::Real im, const QuantLib::Date &start, const QuantLib::Date &end, bool isFull, QuantLib::Real pnl, const std::string &result, const std::string &tradeId="") const =0
	Add a row to the detail report. More...

virtual void	addSummaryRow (const QuantLib::ext::shared_ptr< BacktestReports > &reports, const Data &data, bool isCall, QuantLib::Real im, QuantLib::Size observations, bool isFull, QuantLib::Size exceptions, const std::vector< QuantLib::Size > &ragBounds, const VarBenchmarks &sensiBenchmarks, const VarBenchmarks &fullBenchmarks) const =0
	Add a row to the summary report. More...

virtual void	calculateBenchmarks (VarBenchmarks &benchmarks, QuantLib::Real confidence, const bool isCall, const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup, std::set< std::pair< std::string, QuantLib::Size > > &tradeIdIdxPairs)
	Calculate and update the benchmarks. More...

void	writeReports (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports, const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &tradeGroup) override

std::vector< ore::data::TimePeriod >	timePeriods () override

Protected Member Functions inherited from MarketRiskReport
virtual void	initialiseRiskGroups ()
	Method for shared initialisation. More...

virtual void	registerProgressIndicators ()

virtual void	createReports (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports)=0

virtual bool	runTradeDetail (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports)

virtual QuantLib::ext::shared_ptr< ScenarioFilter >	createScenarioFilter (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup)

virtual void	reset (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup)

virtual bool	runTradeRiskGroup (const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup, const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual bool	disablesAll (const QuantLib::ext::shared_ptr< ScenarioFilter > &filter) const

virtual void	updateFilter (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< ScenarioFilter > &filter)
	update any filters required More...

virtual std::string	portfolioId (const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup) const

virtual std::string	tradeGroupKey (const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup) const

virtual ore::data::TimePeriod	covariancePeriod () const

virtual void	addPnlCalculators (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports)

virtual void	handleSensiResults (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &report, const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup)

virtual void	handleFullRevalResults (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports, const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup)

virtual bool	includeDeltaMargin (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual bool	includeGammaMargin (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual bool	runFullReval (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual bool	generateCube (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual std::string	cubeFilePath (const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup) const

virtual std::vector< ore::data::TimePeriod >	timePeriods ()

virtual void	writeReports (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports, const QuantLib::ext::shared_ptr< MarketRiskGroupBase > &riskGroup, const QuantLib::ext::shared_ptr< TradeGroupBase > &tradeGroup)

virtual void	closeReports (const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &reports)

Protected Attributes
std::unique_ptr< BacktestArgs >	btArgs_

VarBenchmarks	sensiCallBenchmarks_

VarBenchmarks	sensiPostBenchmarks_

VarBenchmarks	fullRevalCallBenchmarks_

VarBenchmarks	fullRevalPostBenchmarks_

std::vector< QuantLib::Real >	bmSensiPnls_
	variables for benchmark calculations More...

std::vector< QuantLib::Real >	bmFoSensiPnls_

std::vector< QuantLib::Real >	pnls_

std::vector< QuantLib::Real >	bmPnls_

std::vector< QuantLib::Real >	sensiPnls_

std::vector< QuantLib::Real >	foSensiPnls_

ore::analytics::TradePnLStore	foTradePnls_

ore::analytics::TradePnLStore	tradePnls_

ore::analytics::TradePnLStore	sensiTradePnls_

std::set< std::string >	callTradeIds_

std::set< std::string >	postTradeIds_

Protected Attributes inherited from MarketRiskReport
bool	sensiBased_ = false

bool	fullReval_ = false

std::string	calculationCurrency_

QuantLib::ext::shared_ptr< Portfolio >	portfolio_

std::string	portfolioFilter_

boost::optional< ore::data::TimePeriod >	period_

QuantLib::ext::shared_ptr< HistoricalScenarioGenerator >	hisScenGen_

std::unique_ptr< SensiRunArgs >	sensiArgs_

std::unique_ptr< FullRevalArgs >	fullRevalArgs_

std::unique_ptr< MultiThreadArgs >	multiThreadArgs_

bool	breakdown_ = false

bool	requireTradePnl_ = false

QuantLib::ext::shared_ptr< MarketRiskGroupBaseContainer >	riskGroups_

QuantLib::ext::shared_ptr< TradeGroupBaseContainer >	tradeGroups_

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

std::set< std::pair< std::string, QuantLib::Size > >	tradeIdIdxPairs_

std::vector< std::string >	tradeIds_

std::map< RiskFactorKey, QuantLib::Real >	deltas_

std::map< std::pair< RiskFactorKey, RiskFactorKey >, QuantLib::Real >	gammas_

QuantLib::Matrix	covarianceMatrix_

bool	writePnl_ = false

std::vector< QuantLib::ext::shared_ptr< PNLCalculator > >	pnlCalculators_

QuantLib::ext::shared_ptr< QuantExt::CovarianceSalvage >	salvage_

bool	includeDeltaMargin_ = true

bool	includeGammaMargin_ = true

QuantLib::ext::shared_ptr< ore::data::EngineFactory >	factory_

QuantLib::ext::shared_ptr< ore::analytics::HistoricalPnlGenerator >	histPnlGen_

QuantLib::ext::shared_ptr< HistoricalSensiPnlCalculator >	sensiPnlCalculator_

Private Member Functions
SummaryResults	calculateSummary (const QuantLib::ext::shared_ptr< BacktestReports > &reports, const Data &data, bool isFull, const std::vector< QuantLib::Real > &pnls, const std::vector< std::string > &tradeIds, const TradePnLStore &tradePnls)

Detailed Description

Definition at line 41 of file marketriskbacktest.hpp.

Member Typedef Documentation

◆ VarBenchmarks

typedef std::map<VarType, std::pair<QuantLib::ext::shared_ptr<ore::analytics::VarCalculator>, QuantLib::Real> > VarBenchmarks

protected

pointers to the VAR benchmarks

Definition at line 159 of file marketriskbacktest.hpp.

Member Enumeration Documentation

◆ VarType

enum class VarType

strong

VAR types used as a benchmark against which SIMM can be compared.

Enumerator
HistSim
HistSimTaylor
Parametric
Lch

Definition at line 44 of file marketriskbacktest.hpp.

44{ HistSim, HistSimTaylor, Parametric, Lch };

ore::analytics::MarketRiskBacktest::VarType::Parametric

@ Parametric

ore::analytics::MarketRiskBacktest::VarType::HistSim

@ HistSim

ore::analytics::MarketRiskBacktest::VarType::Lch

@ Lch

ore::analytics::MarketRiskBacktest::VarType::HistSimTaylor

@ HistSimTaylor

Constructor & Destructor Documentation

◆ MarketRiskBacktest()

MarketRiskBacktest	(	const std::string &	calculationCurrency,
		const QuantLib::ext::shared_ptr< ore::data::Portfolio > &	portfolio,
		const std::string &	portfolioFilter,
		std::unique_ptr< BacktestArgs >	btArgs,
		std::unique_ptr< SensiRunArgs >	sensiArgs = `nullptr`,
		std::unique_ptr< FullRevalArgs >	revalArgs = `nullptr`,
		std::unique_ptr< MultiThreadArgs >	mtArgs = `nullptr`,
		const QuantLib::ext::shared_ptr< ore::analytics::HistoricalScenarioGenerator > &	hisScenGen = `nullptr`,
		const bool	breakdown = `false`,
		const bool	requireTradePnl = `false`
	)

Definition at line 48 of file marketriskbacktest.cpp.

    : MarketRiskReport(calculationCurrency, portfolio, portfolioFilter, btArgs->backtestPeriod_, hisScenGen, std::move(sensiArgs), std::move(revalArgs),
                       std::move(mtArgs), breakdown, requireTradePnl),
      btArgs_(std::move(btArgs)) {
}

◆ ~MarketRiskBacktest()

virtual ~MarketRiskBacktest ( )

virtual

Definition at line 137 of file marketriskbacktest.hpp.

137{}

Member Function Documentation

◆ disablesAll()

bool disablesAll ( const QuantLib::ext::shared_ptr< ore::analytics::ScenarioFilter > & filter ) const

override

Check if the given scenario filter turns off all risk factors in the historical scenario generator

Definition at line 173 of file marketriskbacktest.cpp.

                                                                                              {
    // Return false if we hit any risk factor that is "allowed" i.e. enabled
    for (const auto& key : hisScenGen_->baseScenario()->keys()) {
        if (filter->allow(key)) {
            return false;
        }
    }
    // If we get to here, all risk factors are "not allowed" i.e. disabled
    return true;
}

◆ addPnlRow()

void addPnlRow	(	const QuantLib::ext::shared_ptr< BacktestReports > &	reports,
		QuantLib::Size	scenarioIdx,
		bool	isCall,
		const ore::analytics::RiskFactorKey &	key_1,
		QuantLib::Real	shift_1,
		QuantLib::Real	delta,
		QuantLib::Real	gamma,
		QuantLib::Real	deltaPnl,
		QuantLib::Real	gammaPnl,
		const ore::analytics::RiskFactorKey &	key_2 = `ore::analytics::RiskFactorKey()`,
		QuantLib::Real	shift_2 = `0.0`,
		const std::string &	tradeId = `""`,
		const std::string &	currency = `""`,
		QuantLib::Real	fxSpot = `1.0`
	)

virtual

Add a row to the P&L contribution report.

Definition at line 372 of file marketriskbacktest.cpp.

                                                                                                          {
 
    // Do we have a report to write to?
    // Is this too slow to do on every call to addPnlRow? Need to find the report each time in any case.
    QuantLib::ext::shared_ptr<ore::data::Report> rpt;
    if (tradeId.empty()) {
        if (reports->has(BacktestReports::ReportType::PnlContribution))
            rpt = reports->get(BacktestReports::ReportType::PnlContribution);
    } else {
        if (reports->has(BacktestReports::ReportType::PnlContributionTrade))
            rpt = reports->get(BacktestReports::ReportType::PnlContributionTrade);
    }
 
    // If we have no report or below threshold, do nothing.
    if (!rpt ||
        (std::abs(deltaPnl) < sensiArgs_->pnlWriteThreshold_ && std::abs(gammaPnl) < sensiArgs_->pnlWriteThreshold_))
        return;
 
    // Add the trade ID if we are writing trade level entries.
    auto& report = tradeId.empty() ? rpt->next() : rpt->next().add(tradeId);
 
    // Add the fields common to the trade level and aggregate reports.
    report.add(hisScenGen_->startDates()[scenarioIdx])
        .add(hisScenGen_->endDates()[scenarioIdx])
        .add(isCall ? "call" : "post")
        .add(to_string(key_1))
        .add(to_string(key_2))
        .add(delta)
        .add(gamma)
        .add(shift_1)
        .add(shift_2)
        .add(currency.empty() || currency == calculationCurrency_ ? deltaPnl : deltaPnl / fxSpot)
        .add(currency.empty() || currency == calculationCurrency_ ? gammaPnl : gammaPnl / fxSpot)
        .add(currency.empty() ? calculationCurrency_ : currency);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialise()

void initialise ( )

overrideprotectedvirtual

Reimplemented from MarketRiskReport.

Definition at line 64 of file marketriskbacktest.cpp.

                                    {
    callTradeIds_ = btArgs_->callTradeIds_;
    postTradeIds_ = btArgs_->postTradeIds_;
    
    // If there is a mismatch between call and post, then we will have to exclude trade-level PnLs from the total (scenario) PnL
    requireTradePnl_ = callTradeIds_ != postTradeIds_;
 
    MarketRiskReport::initialise();
}

Here is the call graph for this function:

◆ summaryColumns()

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size > > summaryColumns ( )

protectedpure virtual

Here is the caller graph for this function:

◆ detailColumns()

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size, bool > > detailColumns ( )

protectedpure virtual

Here is the caller graph for this function:

◆ pnlColumns()

virtual const std::vector< std::tuple< std::string, ore::data::Report::ReportType, QuantLib::Size > > pnlColumns ( )

protectedpure virtual

Here is the caller graph for this function:

◆ callValue()

virtual QuantLib::Real callValue ( const Data & data )

protectedpure virtual

Here is the caller graph for this function:

◆ postValue()

virtual QuantLib::Real postValue ( const Data & data )

protectedpure virtual

Here is the caller graph for this function:

◆ counterparty()

virtual std::string counterparty ( const std::string & tradeId ) const

protectedpure virtual

Here is the caller graph for this function:

◆ setUpBenchmarks()

virtual void setUpBenchmarks ( )

protectedpure virtual

◆ reset()

void reset ( const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > & riskGroup )

overrideprotectedvirtual

Definition at line 351 of file marketriskbacktest.cpp.

                                                                                          {
    MarketRiskReport::reset(riskGroup);
    bmSensiPnls_.clear();
    pnls_.clear();
    bmPnls_.clear();
    foSensiPnls_.clear();
    bmFoSensiPnls_.clear();
    sensiPnls_.clear();
    tradePnls_.clear();
    sensiTradePnls_.clear();
    foTradePnls_.clear();
    for (auto& [type, value] : sensiCallBenchmarks_)
        value.second = 0.0;
    for (auto& [type, value] : sensiPostBenchmarks_)
        value.second = 0.0;
    for (auto& [type, value] : fullRevalCallBenchmarks_)
        value.second = 0.0;
    for (auto& [type, value] : fullRevalPostBenchmarks_)
        value.second = 0.0;
}

Here is the call graph for this function:

◆ createReports()

void createReports ( const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > & reports )

overrideprotectedvirtual

Implements MarketRiskReport.

Definition at line 290 of file marketriskbacktest.cpp.

                                                                                            {
 
    auto rpts = ext::dynamic_pointer_cast<BacktestReports>(reports);
    QL_REQUIRE(rpts, "Reports must be of type BacktestReports");
 
    if (rpts->has(BacktestReports::ReportType::Summary)) {
        auto summary = rpts->get(BacktestReports::ReportType::Summary);
        if (summary) {
            for (const auto& t : summaryColumns())
                summary->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
        }
    }
 
    if (rpts->has(BacktestReports::ReportType::Detail)) {
        auto detail = rpts->get(BacktestReports::ReportType::Detail);
        if (detail) {
            for (const auto& t : detailColumns())
                detail->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
        }
    }
 
    if (rpts->has(BacktestReports::ReportType::DetailTrade)) {
        auto detailTrade = rpts->get(BacktestReports::ReportType::DetailTrade);
        if (detailTrade) {
            detailTrade->addColumn("TradeId", string());
            for (const auto& t : detailColumns()) {
                if (btArgs_->tradeDetailIncludeAllColumns_ || std::get<3>(t))
                    detailTrade->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
            }
        }
    }
 
    if (rpts->has(BacktestReports::ReportType::PnlContribution)) {
        auto pnl = rpts->get(BacktestReports::ReportType::PnlContribution);
        if (pnl) {
            for (const auto& t : pnlColumns())
                pnl->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
        }
    }
 
    if (rpts->has(BacktestReports::ReportType::PnlContributionTrade)) {
        auto pnlTrade = rpts->get(BacktestReports::ReportType::PnlContributionTrade);
        if (pnlTrade) {
            pnlTrade->addColumn("TradeId", string());
            for (const auto& t : pnlColumns())
                pnlTrade->addColumn(std::get<0>(t), std::get<1>(t), std::get<2>(t));
        }
    }
}

Here is the call graph for this function:

◆ runTradeDetail()

bool runTradeDetail ( const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > & reports )

overrideprotectedvirtual

Reimplemented from MarketRiskReport.

Definition at line 80 of file marketriskbacktest.cpp.

                                                                                             {
    auto rpts = ext::dynamic_pointer_cast<BacktestReports>(reports);
    bool trdDetail = false;
    if (rpts->has(BacktestReports::ReportType::DetailTrade)) {
        auto detailTrade = rpts->get(BacktestReports::ReportType::DetailTrade);
        trdDetail = detailTrade != nullptr;
    }
    return requireTradePnl_ || trdDetail;
}

Here is the caller graph for this function:

◆ covariancePeriod()

ore::data::TimePeriod covariancePeriod ( ) const

overrideprotectedvirtual

Reimplemented from MarketRiskReport.

Definition at line 179 of file marketriskbacktest.hpp.

179{ return btArgs_->benchmarkPeriod_; }

◆ addPnlCalculators()

void addPnlCalculators ( const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > & reports )

overrideprotectedvirtual

Reimplemented from MarketRiskReport.

Definition at line 90 of file marketriskbacktest.cpp.

                                                                                                {
    pnlCalculators_.push_back(
        QuantLib::ext::make_shared<PNLCalculator>(btArgs_->benchmarkPeriod_));
    auto btRpts = ext::dynamic_pointer_cast<BacktestReports>(reports);
    pnlCalculators_.push_back(
        QuantLib::ext::make_shared<BacktestPNLCalculator>(btArgs_->backtestPeriod_, writePnl_, this, btRpts));
}

◆ handleSensiResults()

void handleSensiResults	(	const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &	reports,
		const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &	riskGroup,
		const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &	tradeGroup
	)

overrideprotected

Definition at line 99 of file marketriskbacktest.cpp.

                                                                                             {
    QL_REQUIRE(pnlCalculators_.size() == 2, "Expecting 2 PNL Calculators for Backtest");
    bmSensiPnls_ = pnlCalculators_[0]->pnls();
    bmFoSensiPnls_ = pnlCalculators_[0]->foPnls();
    sensiPnls_ = pnlCalculators_[1]->pnls();
    foSensiPnls_ = pnlCalculators_[1]->foPnls();
 
    auto backtestPnlCalc = ext::dynamic_pointer_cast < BacktestPNLCalculator>(pnlCalculators_[1]);
    QL_REQUIRE(backtestPnlCalc, "We must have a BacktestPnLCalculator");
    if (runTradeDetail(reports)) {
        foTradePnls_ = backtestPnlCalc->foTradePnls();
        sensiTradePnls_ = backtestPnlCalc->tradePnls();
    }
 
    // Calculate benchmarks
    calculateBenchmarks(sensiCallBenchmarks_, btArgs_->confidence_, true, riskGroup, tradeIdIdxPairs_);
    calculateBenchmarks(sensiPostBenchmarks_, btArgs_->confidence_, false, riskGroup, tradeIdIdxPairs_);
}

Here is the call graph for this function:

◆ handleFullRevalResults()

void handleFullRevalResults	(	const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &	reports,
		const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &	riskGroup,
		const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &	tradeGroup
	)

overrideprotected

Definition at line 120 of file marketriskbacktest.cpp.

                                                                                                             {
 
    QL_REQUIRE(histPnlGen_, "Must have a Historical PNL Generator");
    pnls_ = histPnlGen_->pnl(btArgs_->backtestPeriod_, tradeIdIdxPairs_);
    bmPnls_ = histPnlGen_->pnl(btArgs_->benchmarkPeriod_, tradeIdIdxPairs_);
 
    if (runTradeDetail(reports))
        tradePnls_ = histPnlGen_->tradeLevelPnl(btArgs_->backtestPeriod_, tradeIdIdxPairs_);
 
    adjustFullRevalPnls(pnls_, bmPnls_, tradePnls_, foSensiPnls_, bmFoSensiPnls_, foTradePnls_, riskGroup);
 
    calculateBenchmarks(fullRevalCallBenchmarks_, btArgs_->confidence_, true, riskGroup, tradeIdIdxPairs_);
    calculateBenchmarks(fullRevalPostBenchmarks_, btArgs_->confidence_, false, riskGroup, tradeIdIdxPairs_);
}

Here is the call graph for this function:

◆ adjustFullRevalPnls()

virtual void adjustFullRevalPnls	(	std::vector< QuantLib::Real > &	pnls,
		std::vector< QuantLib::Real > &	bmPnls,
		ore::analytics::TradePnLStore &	tradePnls,
		const std::vector< QuantLib::Real > &	foSensiPnls,
		const std::vector< QuantLib::Real > &	bmFoSensiPnls,
		const ore::analytics::TradePnLStore &	foTradePnls,
		const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &	riskGroup
	)

protectedvirtual

Definition at line 190 of file marketriskbacktest.hpp.

195 {};

Here is the caller graph for this function:

◆ addDetailRow()

virtual void addDetailRow	(	const QuantLib::ext::shared_ptr< BacktestReports > &	reports,
		const Data &	data,
		bool	isCall,
		QuantLib::Real	im,
		const QuantLib::Date &	start,
		const QuantLib::Date &	end,
		bool	isFull,
		QuantLib::Real	pnl,
		const std::string &	result,
		const std::string &	tradeId = `""`
	)		const

protectedpure virtual

Add a row to the detail report.

Here is the caller graph for this function:

◆ addSummaryRow()

virtual void addSummaryRow	(	const QuantLib::ext::shared_ptr< BacktestReports > &	reports,
		const Data &	data,
		bool	isCall,
		QuantLib::Real	im,
		QuantLib::Size	observations,
		bool	isFull,
		QuantLib::Size	exceptions,
		const std::vector< QuantLib::Size > &	ragBounds,
		const VarBenchmarks &	sensiBenchmarks,
		const VarBenchmarks &	fullBenchmarks
	)		const

protectedpure virtual

Add a row to the summary report.

Here is the caller graph for this function:

◆ calculateBenchmarks()

void calculateBenchmarks	(	VarBenchmarks &	benchmarks,
		QuantLib::Real	confidence,
		const bool	isCall,
		const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &	riskGroup,
		std::set< std::pair< std::string, QuantLib::Size > > &	tradeIdIdxPairs
	)

protectedvirtual

Calculate and update the benchmarks.

Definition at line 340 of file marketriskbacktest.cpp.

                         {    
    for (auto& [type, value] : benchmarks) {
        if (value.first)
            value.second = value.first->var(confidence, isCall, tradeIdIdxPairs);
    }
}

Here is the caller graph for this function:

◆ writeReports()

void writeReports	(	const QuantLib::ext::shared_ptr< MarketRiskReport::Reports > &	reports,
		const QuantLib::ext::shared_ptr< ore::analytics::MarketRiskGroupBase > &	riskGroup,
		const QuantLib::ext::shared_ptr< ore::analytics::TradeGroupBase > &	tradeGroup
	)

overrideprotected

Definition at line 137 of file marketriskbacktest.cpp.

                                                                                                   {
 
    // Data for the current backtest
    std::string cpty = tradeIdIdxPairs_.empty() ? "INVALID" : counterparty(tradeIdIdxPairs_.begin()->first);
    Data data = {cpty, tradeGroup, riskGroup};
 
    auto backtestRpts = ext::dynamic_pointer_cast<BacktestReports>(reports);
    QL_REQUIRE(backtestRpts, "We must have backtest reports");
 
    SummaryResults srSensi;
    bool runSensi = sensiPnls_.size() > 0;
    if (runSensi)
        // Give back summary results for sensitivity backtest
        srSensi = calculateSummary(backtestRpts, data, false, sensiPnls_, tradeIds_, sensiTradePnls_);
    
    if (runFullReval(riskGroup)) {
        // Give back summary results for full revaluation backtest
        SummaryResults srFull = calculateSummary(backtestRpts, data, true, pnls_, tradeIds_, tradePnls_);
 
        // Write the rows in the summary report
        addSummaryRow(backtestRpts, data, true, srFull.callValue, srFull.observations, true, srFull.callExceptions,
                      srFull.bounds, sensiCallBenchmarks_, fullRevalCallBenchmarks_);
        addSummaryRow(backtestRpts, data, false, srFull.postValue, srFull.observations, true, srFull.postExceptions,
                      srFull.bounds, sensiPostBenchmarks_, fullRevalPostBenchmarks_);
    }
 
     if (runSensi) {
        addSummaryRow(backtestRpts, data, true, srSensi.callValue, srSensi.observations, false, srSensi.callExceptions,
                      srSensi.bounds, sensiCallBenchmarks_, fullRevalCallBenchmarks_);
        addSummaryRow(backtestRpts, data, false, srSensi.postValue, srSensi.observations, false, srSensi.postExceptions,
                      srSensi.bounds, sensiPostBenchmarks_, fullRevalPostBenchmarks_);
    }
}

Here is the call graph for this function:

◆ timePeriods()

std::vector< ore::data::TimePeriod > timePeriods ( )

overrideprotectedvirtual

Reimplemented from MarketRiskReport.

Definition at line 75 of file marketriskbacktest.cpp.

                                                             { 
    std::vector<TimePeriod> tps{btArgs_->benchmarkPeriod_, btArgs_->backtestPeriod_};
    return tps;
}

◆ calculateSummary()

MarketRiskBacktest::SummaryResults calculateSummary	(	const QuantLib::ext::shared_ptr< BacktestReports > &	reports,
		const Data &	data,
		bool	isFull,
		const std::vector< QuantLib::Real > &	pnls,
		const std::vector< std::string > &	tradeIds,
		const TradePnLStore &	tradePnls
	)

private

Calculate the number of exceptions given the current data and the associated P&L vector pnls for both call and post sides. The parameter isFull is true if pnls come from a full revaluation and false if they are sensitivity based.

The parameters tradeIds and tradePnls are used if we are writing a trade level backtest detail report.

Definition at line 184 of file marketriskbacktest.cpp.

                                                                                 {
 
    SummaryResults sr = {pnls.size(), 0.0, 0, 0.0, 0, {}};
 
    sr.callValue = callValue(data);
    sr.postValue = postValue(data);    
 
    auto pnlScenDates = hisScenGen_->filteredScenarioDates(btArgs_->backtestPeriod_);
    QL_REQUIRE(pnlScenDates.size() == pnls.size(), "Backtest::calculateSummary(): internal error, pnlScenDates ("
                                                       << pnlScenDates.size() << ") do not match pnls (" << pnls.size()
                                                       << ")");
 
    // If a trade level backtest detail report has been requested.
    bool detailTrd = runTradeDetail(reports);
    if (detailTrd)
        QL_REQUIRE(pnls.size() == tradePnls.size(), "For trade level backtest detail report,"
                                                        << " expect the number of aggregate P&Ls (" << pnls.size()
                                                        << ") to equal the number"
                                                        << " of trade P&Ls (" << tradePnls.size() << ").");
 
    // List of trades to exclude in the PnL calcs.
    // This would happen when a trade is under a winning reg in the call side but not on the post side, or vice versa.
    vector<Size> callTradesToSkip;
    vector<Size> postTradesToSkip;
    if (requireTradePnl_) {
        for (Size t = 0; t < tradeIds.size(); t++) {
            const string& tid = tradeIds[t];
            if (callTradeIds_.find(tid) == callTradeIds_.end())
                callTradesToSkip.push_back(t);
            if (postTradeIds_.find(tid) == postTradeIds_.end())
                postTradesToSkip.push_back(t);
        }
    }
 
    Real callScenPnl;
    Real postScenPnl;
    vector<Real> scenTradePnls;
    string cPassFail;
    string pPassFail;
    for (Size i = 0; i < pnls.size(); i++) {
        const auto& start = pnlScenDates[i].first;
        const auto& end = pnlScenDates[i].second;
 
        // Deal with call and write report row
        callScenPnl = pnls[i];
        if (!callTradesToSkip.empty()) {
            scenTradePnls = tradePnls[i];
            for (const Size& t : callTradesToSkip) {
                callScenPnl -= scenTradePnls[t];
            }
        }
        if (callScenPnl > std::max(sr.callValue, btArgs_->exceptionThreshold_))
            sr.callExceptions++;
 
        cPassFail = callScenPnl > std::max(sr.callValue, btArgs_->exceptionThreshold_) ? "fail" : "pass";
        addDetailRow(reports, data, true, sr.callValue, start, end, isFull, callScenPnl, cPassFail);
 
        // Deal with post and write report row
        postScenPnl = pnls[i];
        if (!postTradesToSkip.empty()) {
            scenTradePnls = tradePnls[i];
            for (const Size& t : postTradesToSkip) {
                postScenPnl -= scenTradePnls[t];
            }
        }
        if (-postScenPnl > std::max(sr.postValue, btArgs_->exceptionThreshold_))
            sr.postExceptions++;
        pPassFail = -postScenPnl > std::max(sr.postValue, btArgs_->exceptionThreshold_) ? "fail" : "pass";
        addDetailRow(reports, data, false, sr.postValue, start, end, isFull, -postScenPnl, pPassFail);
 
        // Add the trade level breakdown if requested. Note that we are clearly not recomputing the IM for the
        // trade - all we are doing is adding the P&L for each trade and the trade ID.
        if (detailTrd && !data.tradeGroup->allLevel()) {
            const auto& scenTradePnls = tradePnls[i];
            QL_REQUIRE(tradeIds.size() == scenTradePnls.size(), "For trade level backtest detail report,"
                                                                    << " the number of trades (" << tradeIds.size()
                                                                    << ") does not equal the size of the trade level P&L"
                                                                    << " container (" << scenTradePnls.size()
                                                                    << ") on scenario date " << io::iso_date(start)
                                                                    << ".");
            for (Size j = 0; j < scenTradePnls.size(); ++j) {
                if (std::find(callTradesToSkip.begin(), callTradesToSkip.end(), j) == callTradesToSkip.end())
                    addDetailRow(reports, data, true, sr.callValue, start, end, isFull, scenTradePnls[j], cPassFail, tradeIds[j]);
                if (std::find(postTradesToSkip.begin(), postTradesToSkip.end(), j) == postTradesToSkip.end())
                    addDetailRow(reports, data, false, sr.postValue, start, end, isFull, -scenTradePnls[j], pPassFail, tradeIds[j]);
            }
        }
    }
 
    LOG("Got " << sr.callExceptions << " Call exceptions from " << sr.observations << " observations.");
    LOG("Got " << sr.postExceptions << " Post exceptions from " << sr.observations << " observations.");
 
    // Now calculate the [red, amber] and [amber, green] bounds
    if (hisScenGen_->mporDays() != 10) {
        ALOG("SimmBacktest: MPOR days is " << hisScenGen_->mporDays());
    } else {
        sr.bounds = hisScenGen_->overlapping() ? QuantExt::stopLightBoundsTabulated(btArgs_->ragLevels_, sr.observations,
                                                   hisScenGen_->mporDays(), btArgs_->confidence_)
                        : QuantExt::stopLightBounds(btArgs_->ragLevels_, sr.observations, btArgs_->confidence_);
    }
 
    return sr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ btArgs_

std::unique_ptr<BacktestArgs> btArgs_

protected

Definition at line 153 of file marketriskbacktest.hpp.

◆ sensiCallBenchmarks_

VarBenchmarks sensiCallBenchmarks_

protected

Definition at line 160 of file marketriskbacktest.hpp.

◆ sensiPostBenchmarks_

VarBenchmarks sensiPostBenchmarks_

protected

Definition at line 160 of file marketriskbacktest.hpp.

◆ fullRevalCallBenchmarks_

VarBenchmarks fullRevalCallBenchmarks_

protected

Definition at line 160 of file marketriskbacktest.hpp.

◆ fullRevalPostBenchmarks_

VarBenchmarks fullRevalPostBenchmarks_

protected

Definition at line 160 of file marketriskbacktest.hpp.

◆ bmSensiPnls_

std::vector<QuantLib::Real> bmSensiPnls_

protected

variables for benchmark calculations

Definition at line 163 of file marketriskbacktest.hpp.

◆ bmFoSensiPnls_

std::vector<QuantLib::Real> bmFoSensiPnls_

protected

Definition at line 163 of file marketriskbacktest.hpp.

◆ pnls_

std::vector<QuantLib::Real> pnls_

protected

Definition at line 163 of file marketriskbacktest.hpp.

◆ bmPnls_

std::vector<QuantLib::Real> bmPnls_

protected

Definition at line 163 of file marketriskbacktest.hpp.

◆ sensiPnls_

std::vector<QuantLib::Real> sensiPnls_

protected

Definition at line 163 of file marketriskbacktest.hpp.

◆ foSensiPnls_

std::vector<QuantLib::Real> foSensiPnls_

protected

Definition at line 163 of file marketriskbacktest.hpp.

◆ foTradePnls_

ore::analytics::TradePnLStore foTradePnls_

protected

Definition at line 164 of file marketriskbacktest.hpp.

◆ tradePnls_

ore::analytics::TradePnLStore tradePnls_

protected

Definition at line 164 of file marketriskbacktest.hpp.

◆ sensiTradePnls_

ore::analytics::TradePnLStore sensiTradePnls_

protected

Definition at line 164 of file marketriskbacktest.hpp.

◆ callTradeIds_

std::set<std::string> callTradeIds_

protected

Definition at line 165 of file marketriskbacktest.hpp.

◆ postTradeIds_

std::set<std::string> postTradeIds_

protected

Definition at line 166 of file marketriskbacktest.hpp.

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ VarBenchmarks

Member Enumeration Documentation

◆ VarType

Constructor & Destructor Documentation

◆ MarketRiskBacktest()

◆ ~MarketRiskBacktest()

Member Function Documentation

◆ disablesAll()

◆ addPnlRow()

◆ initialise()

◆ summaryColumns()

◆ detailColumns()

◆ pnlColumns()

◆ callValue()

◆ postValue()

◆ counterparty()

◆ setUpBenchmarks()

◆ reset()

◆ createReports()

◆ runTradeDetail()

◆ covariancePeriod()

◆ addPnlCalculators()

◆ handleSensiResults()

◆ handleFullRevalResults()

◆ adjustFullRevalPnls()

◆ addDetailRow()

◆ addSummaryRow()

◆ calculateBenchmarks()

◆ writeReports()

◆ timePeriods()

◆ calculateSummary()

Member Data Documentation

◆ btArgs_

◆ sensiCallBenchmarks_

◆ sensiPostBenchmarks_

◆ fullRevalCallBenchmarks_

◆ fullRevalPostBenchmarks_

◆ bmSensiPnls_

◆ bmFoSensiPnls_

◆ pnls_

◆ bmPnls_

◆ sensiPnls_

◆ foSensiPnls_

◆ foTradePnls_

◆ tradePnls_

◆ sensiTradePnls_

◆ callTradeIds_

◆ postTradeIds_