#include <orea/engine/historicalpnlgenerator.hpp>

Inheritance diagram for HistoricalPnlGenerator:

Collaboration diagram for HistoricalPnlGenerator:

Public Types
using	TradePnlStore = std::vector< std::vector< QuantLib::Real > >

Public Member Functions
	HistoricalPnlGenerator (const std::string &baseCurrency, const QuantLib::ext::shared_ptr< ore::data::Portfolio > &portfolio, const QuantLib::ext::shared_ptr< ScenarioSimMarket > &simMarket, const QuantLib::ext::shared_ptr< HistoricalScenarioGenerator > &hisScenGen, const QuantLib::ext::shared_ptr< NPVCube > &cube, const set< std::pair< string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > > &modelBuilders={}, bool dryRun=false)

	HistoricalPnlGenerator (const string &baseCurrency, const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< HistoricalScenarioGenerator > &hisScenGen, const QuantLib::ext::shared_ptr< EngineData > &engineData, const Size nThreads, const Date &today, const QuantLib::ext::shared_ptr< ore::data::Loader > &loader, const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &curveConfigs, const QuantLib::ext::shared_ptr< ore::data::TodaysMarketParameters > &todaysMarketParams, const std::string &configuration, const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &simMarketData, const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceData=nullptr, const IborFallbackConfig &iborFallbackConfig=IborFallbackConfig::defaultConfig(), bool dryRun=false, const std::string &context="historical pnl generation")

void	generateCube (const QuantLib::ext::shared_ptr< ScenarioFilter > &filter)

std::vector< QuantLib::Real >	pnl (const ore::data::TimePeriod &period, const std::set< std::pair< std::string, QuantLib::Size > > &tradeIds) const

std::vector< QuantLib::Real >	pnl (const ore::data::TimePeriod &period) const

std::vector< QuantLib::Real >	pnl (const std::set< std::pair< std::string, QuantLib::Size > > &tradeIds) const

std::vector< QuantLib::Real >	pnl () const

TradePnlStore	tradeLevelPnl (const ore::data::TimePeriod &period, const std::set< std::pair< std::string, QuantLib::Size > > &tradeIds) const

TradePnlStore	tradeLevelPnl (const ore::data::TimePeriod &period) const

TradePnlStore	tradeLevelPnl (const std::set< std::pair< std::string, QuantLib::Size > > &tradeIds) const

TradePnlStore	tradeLevelPnl () const

const QuantLib::ext::shared_ptr< NPVCube > &	cube () const

std::set< std::pair< std::string, QuantLib::Size > >	tradeIdIndexPairs () const
	Set of trade ID and index pairs for all trades. More...

ore::data::TimePeriod	timePeriod () const
	Time period covered by the historical P&L generator. More...

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

Private Member Functions
QuantLib::Size	indexAsof () const
	Get the index of the as of date in the cube. More...

Private Attributes
bool	useSingleThreadedEngine_

QuantLib::ext::shared_ptr< ore::data::Portfolio >	portfolio_

QuantLib::ext::shared_ptr< ScenarioSimMarket >	simMarket_

QuantLib::ext::shared_ptr< HistoricalScenarioGenerator >	hisScenGen_

QuantLib::ext::shared_ptr< NPVCube >	cube_

QuantLib::ext::shared_ptr< ValuationEngine >	valuationEngine_

QuantLib::ext::shared_ptr< ore::data::EngineData >	engineData_

Size	nThreads_

Date	today_

QuantLib::ext::shared_ptr< ore::data::Loader >	loader_

QuantLib::ext::shared_ptr< ore::data::CurveConfigurations >	curveConfigs_

QuantLib::ext::shared_ptr< ore::data::TodaysMarketParameters >	todaysMarketParams_

std::string	configuration_

QuantLib::ext::shared_ptr< ScenarioSimMarketParameters >	simMarketData_

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

ore::data::IborFallbackConfig	iborFallbackConfig_

bool	dryRun_

std::string	context_

std::function< std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > >()>	npvCalculator_

Detailed Description

Class for generating historical P&L vectors for a given portfolio in a given currency.

In particular, assume that the portfolio has a base NPV, \(\Pi_0\), today i.e. at \(t_0\). This class takes a HistoricalScenarioGenerator which holds a set of historical market moves, over a given period \(\tau\) e.g. 10 business days, for a set of past dates \(\{d_1, d_2, \ldots, d_N\}\). This class calculates the P&L changes on the portfolio, \(\{\Delta_1, \Delta_2, \ldots, \Delta_N\}\), resulting from applying these market moves to the base market. In other words, \(\Delta_i = \Pi_i - \Pi_0 \) where \(\Pi_i\) is the portfolio NPV under the shifted market corresponding to date \(d_i\) for \(i = 1, 2, \ldots, N\).

In the calculation of P&L, the class allows the scenario shifts to be filtered and also the trades to be filtered.

Definition at line 52 of file historicalpnlgenerator.hpp.

Member Typedef Documentation

◆ TradePnlStore

using TradePnlStore = std::vector<std::vector<QuantLib::Real> >

Return a vector of historical trade level P&L values restricted to scenarios falling in period and restricted to the given tradeIds. The P&L values are calculated from the last cube generated by generateCube. The first dimension is time and the second dimension is tradeId.

Definition at line 117 of file historicalpnlgenerator.hpp.

Constructor & Destructor Documentation

◆ HistoricalPnlGenerator() [1/2]

HistoricalPnlGenerator	(	const std::string &	baseCurrency,
		const QuantLib::ext::shared_ptr< ore::data::Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< ScenarioSimMarket > &	simMarket,
		const QuantLib::ext::shared_ptr< HistoricalScenarioGenerator > &	hisScenGen,
		const QuantLib::ext::shared_ptr< NPVCube > &	cube,
		const set< std::pair< string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > > &	modelBuilders = `{}`,
		bool	dryRun = `false`
	)

Constructor to use a single-threaded valuation engine

Parameters

baseCurrency	currency in which the P&Ls will be calculated
portfolio	portfolio of trades for which P&Ls will be calculated
simMarket	simulation market used for valuation
hisScenGen	historical scenario generator
cube	an NPV cube that will be populated by each call to generateCube
modelBuilders	model builders to update during a val engine run
dryRun	for testing - limit the number of scenarios to one and fill the cube with random data

◆ HistoricalPnlGenerator() [2/2]

HistoricalPnlGenerator	(	const string &	baseCurrency,
		const QuantLib::ext::shared_ptr< Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< HistoricalScenarioGenerator > &	hisScenGen,
		const QuantLib::ext::shared_ptr< EngineData > &	engineData,
		const Size	nThreads,
		const Date &	today,
		const QuantLib::ext::shared_ptr< ore::data::Loader > &	loader,
		const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &	curveConfigs,
		const QuantLib::ext::shared_ptr< ore::data::TodaysMarketParameters > &	todaysMarketParams,
		const std::string &	configuration,
		const QuantLib::ext::shared_ptr< ScenarioSimMarketParameters > &	simMarketData,
		const QuantLib::ext::shared_ptr< ReferenceDataManager > &	referenceData = `nullptr`,
		const IborFallbackConfig &	iborFallbackConfig = `IborFallbackConfig::defaultConfig()`,
		bool	dryRun = `false`,
		const std::string &	context = `"historical pnl generation"`
	)

Constructor to use a multi-threaded valuation engine

Member Function Documentation

◆ generateCube()

void generateCube ( const QuantLib::ext::shared_ptr< ScenarioFilter > & filter )

Generate a "cube" of P&L values for the trades in the portfolio on each of the scenarios provided by the historical scenario generator. The historical scenarios will have the given filter applied.

Definition at line 96 of file historicalpnlgenerator.cpp.

                                                                                             {
 
    DLOG("Filling historical P&L cube for " << portfolio_->size() << " trades and " << hisScenGen_->numScenarios()
                                            << " scenarios.");
 
    if (useSingleThreadedEngine_) {
 
        valuationEngine_->unregisterAllProgressIndicators();
        for (auto const& i : this->progressIndicators()) {
            i->reset();
            valuationEngine_->registerProgressIndicator(i);
        }
 
        hisScenGen_->reset();
        simMarket_->filter() = filter;
        simMarket_->reset();
        simMarket_->scenarioGenerator() = hisScenGen_;
        hisScenGen_->baseScenario() = simMarket_->baseScenario();
        valuationEngine_->buildCube(portfolio_, cube_, npvCalculator_(), true, nullptr, nullptr, {}, dryRun_);
 
    } else {
        MultiThreadedValuationEngine engine(
            nThreads_, today_, QuantLib::ext::make_shared<ore::analytics::DateGrid>(), hisScenGen_->numScenarios(), loader_,
            hisScenGen_, engineData_, curveConfigs_, todaysMarketParams_, configuration_, simMarketData_, false, false,
            filter, referenceData_, iborFallbackConfig_, true, true, true, {}, {}, {}, context_);
        for (auto const& i : this->progressIndicators()) {
            i->reset();
            engine.registerProgressIndicator(i);
        }
        engine.buildCube(portfolio_, npvCalculator_, {}, true, dryRun_);
        cube_ = QuantLib::ext::make_shared<JointNPVCube>(engine.outputCubes(), portfolio_->ids(), true);
    }
 
    DLOG("Historical P&L cube generated");
}

Here is the call graph for this function:

◆ pnl() [1/4]

std::vector< QuantLib::Real > pnl	(	const ore::data::TimePeriod &	period,
		const std::set< std::pair< std::string, QuantLib::Size > > &	tradeIds
	)		const

Return a vector of historical portfolio P&L values restricted to scenarios falling in period and restricted to the given tradeIds. The P&L values are calculated from the last cube generated by generateCube.

◆ pnl() [2/4]

vector< Real > pnl ( const ore::data::TimePeriod & period ) const

Return a vector of historical portfolio P&L values restricted to scenarios falling in period. The P&L values are calculated from the last cube generated by generateCube.

Definition at line 161 of file historicalpnlgenerator.cpp.

161{ return pnl(period, tradeIdIndexPairs()); }

ore::analytics::HistoricalPnlGenerator::pnl

std::vector< QuantLib::Real > pnl() const

Definition: historicalpnlgenerator.cpp:167

ore::analytics::HistoricalPnlGenerator::tradeIdIndexPairs

std::set< std::pair< std::string, QuantLib::Size > > tradeIdIndexPairs() const

Set of trade ID and index pairs for all trades.

Definition: historicalpnlgenerator.cpp:228

◆ pnl() [3/4]

std::vector< QuantLib::Real > pnl ( const std::set< std::pair< std::string, QuantLib::Size > > & tradeIds ) const

Return a vector of historical portfolio P&L values restricted to the given tradeIds. The P&L values are calculated from the last cube generated by generateCube.

◆ pnl() [4/4]

vector< Real > pnl ( ) const

Return a vector of historical portfolio P&L values for all scenarios generated by the historical scenario generator. The P&L values are calculated from the last cube generated by generateCube.

Definition at line 167 of file historicalpnlgenerator.cpp.

167{ return pnl(timePeriod()); }

ore::analytics::HistoricalPnlGenerator::timePeriod

ore::data::TimePeriod timePeriod() const

Time period covered by the historical P&L generator.

Definition: historicalpnlgenerator.cpp:236

◆ tradeLevelPnl() [1/4]

TradePnlStore tradeLevelPnl	(	const ore::data::TimePeriod &	period,
		const std::set< std::pair< std::string, QuantLib::Size > > &	tradeIds
	)		const

◆ tradeLevelPnl() [2/4]

TradePnlStore tradeLevelPnl ( const ore::data::TimePeriod & period ) const

Return a vector of historical trade level P&L values restricted to scenarios falling in period. The P&L values are calculated from the last cube generated by generateCube. The first dimension is time and the second dimension is tradeId.

Definition at line 216 of file historicalpnlgenerator.cpp.

                                                                                         {
    return tradeLevelPnl(period, tradeIdIndexPairs());
}

◆ tradeLevelPnl() [3/4]

TradePnlStore tradeLevelPnl ( const std::set< std::pair< std::string, QuantLib::Size > > & tradeIds ) const

Return a vector of historical trade level P&L values restricted to the given tradeIds. The P&L values are calculated from the last cube generated by generateCube. The first dimension is time and the second dimension is tradeId.

◆ tradeLevelPnl() [4/4]

TradePnlStore tradeLevelPnl ( ) const

Return a vector of historical trade level P&L values for all scenarios generated by the historical scenario generator. The P&L values are calculated from the last cube generated by generateCube. The first dimension is time and the second dimension is tradeId.

Definition at line 224 of file historicalpnlgenerator.cpp.

224{ return tradeLevelPnl(timePeriod()); }

◆ cube()

const QuantLib::ext::shared_ptr< NPVCube > & cube ( ) const

Return the last cube generated by generateCube.

Definition at line 226 of file historicalpnlgenerator.cpp.

226{ return cube_; }

◆ tradeIdIndexPairs()

set< pair< string, Size > > tradeIdIndexPairs ( ) const

Set of trade ID and index pairs for all trades.

Definition at line 228 of file historicalpnlgenerator.cpp.

                                                                        {
    set<pair<string, Size>> res;
    Size i = 0;
    for (const auto& [id, trade]: portfolio_->trades())
        res.insert(std::make_pair(id, i++));
    return res;
}

◆ timePeriod()

TimePeriod timePeriod ( ) const

Time period covered by the historical P&L generator.

Definition at line 236 of file historicalpnlgenerator.cpp.

                                                    {
    vector<Date> dates{hisScenGen_->startDates().front(), hisScenGen_->endDates().back()};
    return TimePeriod(dates);
}

Here is the call graph for this function:

◆ indexAsof()

Size indexAsof ( ) const

private

Get the index of the as of date in the cube.

Definition at line 241 of file historicalpnlgenerator.cpp.

                                             {
    Date asof = useSingleThreadedEngine_ ? simMarket_->asofDate() : today_;
    const auto& dates = cube_->dates();
    auto it = std::find(dates.begin(), dates.end(), asof);
    QL_REQUIRE(it != dates.end(), "Can't find an index for asof date " << asof << " in cube");
    return std::distance(dates.begin(), it);
}