PnlExplainAnalyticImpl Class Reference

#include <orea/app/analytics/pnlexplainanalytic.hpp>

Inheritance diagram for PnlExplainAnalyticImpl:

Collaboration diagram for PnlExplainAnalyticImpl:

Public Member Functions
	PnlExplainAnalyticImpl (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
virtual void	runAnalytic (const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader, const std::set< std::string > &runTypes={}) override
virtual void	setUpConfigurations () override
Public Member Functions inherited from Analytic::Impl
	Impl ()
	Impl (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
virtual	~Impl ()
virtual void	runAnalytic (const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &loader, const std::set< std::string > &runTypes={})=0
virtual void	setUpConfigurations ()
virtual QuantLib::ext::shared_ptr< ore::data::EngineFactory >	engineFactory ()
	build an engine factory More...
void	setLabel (const string &label)
const std::string &	label () const
void	setAnalytic (Analytic *analytic)
Analytic *	analytic () const
void	setInputs (const QuantLib::ext::shared_ptr< InputParameters > &inputs)
bool	generateAdditionalResults () const
void	setGenerateAdditionalResults (const bool generateAdditionalResults)
bool	hasDependentAnalytic (const std::string &key)
template<class T >
QuantLib::ext::shared_ptr< T >	dependentAnalytic (const std::string &key) const
QuantLib::ext::shared_ptr< Analytic >	dependentAnalytic (const std::string &key) const
const std::map< std::string, QuantLib::ext::shared_ptr< Analytic > > &	dependentAnalytics () const
void	addDependentAnalytic (const std::string &key, const QuantLib::ext::shared_ptr< Analytic > &analytic)
std::vector< QuantLib::ext::shared_ptr< Analytic > >	allDependentAnalytics () const
virtual std::vector< QuantLib::Date >	additionalMarketDates () const

Static Public Attributes
static constexpr const char *	LABEL = "PNL_EXPLAIN"
static constexpr const char *	sensiLookupKey = "SENSI"
static constexpr const char *	pnlLookupKey = "PNL"

Additional Inherited Members
Protected Attributes inherited from Analytic::Impl
QuantLib::ext::shared_ptr< InputParameters >	inputs_
std::string	label_
	label for logging purposes primarily More...
std::map< std::string, QuantLib::ext::shared_ptr< Analytic > >	dependentAnalytics_

Detailed Description

Definition at line 33 of file pnlexplainanalytic.hpp.

Constructor & Destructor Documentation

PnlExplainAnalyticImpl()

PnlExplainAnalyticImpl

(

const QuantLib::ext::shared_ptr< InputParameters > &

inputs

)

Definition at line 38 of file pnlexplainanalytic.hpp.

        : Analytic::Impl(inputs) {
        setLabel(LABEL);
        
        auto sensiAnalytic = AnalyticFactory::instance().build("SENSITIVITY", inputs_);
        if (sensiAnalytic.second)
            addDependentAnalytic(sensiLookupKey, sensiAnalytic.second);
 
        auto pnlAnalytic = AnalyticFactory::instance().build("PNL", inputs_);
        if (pnlAnalytic.second)
            addDependentAnalytic(pnlLookupKey, pnlAnalytic.second);
    }

Here is the call graph for this function:

Member Function Documentation

runAnalytic()

void runAnalytic ( const QuantLib::ext::shared_ptr< ore::data::InMemoryLoader > &  loader, const std::set< std::string > &  runTypes = {}  )

overridevirtual

Implements Analytic::Impl.

Definition at line 42 of file pnlexplainanalytic.cpp.

                                           {
    
    CONSOLEW("PNL Explain: Build Market");
    analytic()->buildMarket(loader);
    CONSOLE("OK");
 
    CONSOLEW("PNL Explain: Build Portfolio");
    analytic()->buildPortfolio();
    CONSOLE("OK");
 
    auto pnlexplainAnalytic = static_cast<PnlExplainAnalytic*>(analytic());
    QL_REQUIRE(pnlexplainAnalytic, "Analytic must be of type PnlExplainAnalytic");
 
    auto pnlAnalytic = dependentAnalytic(pnlLookupKey);
    pnlAnalytic->runAnalytic(loader);
    auto pnlReport = pnlAnalytic->reports().at("PNL").at("pnl");
 
    auto sensiAnalytic = dependentAnalytic(sensiLookupKey);
 
    // Explicitily set the sensi threshold to 0.0 for sensi analysis, this ensures we get a felta entry for each gamma
    // TODO: Pass the threshold into the sensi analytic
    inputs_->setSensiThreshold(QuantLib::Null<QuantLib::Real>());
    sensiAnalytic->runAnalytic(loader, {"SENSITIVITY"});
 
    auto sensireport = sensiAnalytic->reports().at("SENSITIVITY").at("sensitivity");
    analytic()->reports()[label_]["sensitivity"] = sensireport;
    ext::shared_ptr<SensitivityStream> ss = ext::make_shared<SensitivityReportStream>(sensiAnalytic->reports().at("SENSITIVITY").at("sensitivity"));
    ss = ext::make_shared<FilteredSensitivityStream>(ss, 1e-6);
 
    auto sensiReports = sensiAnalytic->reports();
 
    QuantLib::ext::shared_ptr<ore::data::AdjustmentFactors> adjFactors;
    if (auto adjLoader = QuantLib::ext::dynamic_pointer_cast<AdjustedInMemoryLoader>(loader))
        adjFactors = QuantLib::ext::make_shared<ore::data::AdjustmentFactors>(adjLoader->adjustmentFactors());
 
    // dates needed for scenarios
    set<Date> pnlDates;
    pnlDates.insert(inputs_->asof());
    pnlDates.insert(inputs_->mporDate());
    TimePeriod period({inputs_->asof(), inputs_->mporDate()});
 
    QuantLib::ext::shared_ptr<HistoricalScenarioGenerator> scenarios;
    if (!inputs_->historicalScenarioReader()) {
        
        auto pnlImpl = static_cast<PnlAnalyticImpl*>(pnlAnalytic->impl().get());
        QL_REQUIRE(pnlImpl, "Impl must of type PNLAnalyticImpl");
        auto t0Scenario = pnlImpl->t0Scenario();
        auto t1Scenario = pnlImpl->t1Scenario();
 
        analytic()->reports()[label_]["pnl_scenario_t0"] = pnlAnalytic->reports().at("PNL").at("pnl_scenario_t0");
        analytic()->reports()[label_]["pnl_scenario_t1"] = pnlAnalytic->reports().at("PNL").at("pnl_scenario_t1");
 
        vector<QuantLib::ext::shared_ptr<ore::analytics::Scenario>> histScens = {t0Scenario, t1Scenario};
 
        QuantLib::ext::shared_ptr<HistoricalScenarioLoader> scenarioLoader =
            QuantLib::ext::make_shared<HistoricalScenarioLoader>(histScens, pnlDates);
        
        scenarios = QuantLib::ext::make_shared<HistoricalScenarioGenerator>(
            scenarioLoader, QuantLib::ext::make_shared<SimpleScenarioFactory>(), adjFactors,
            ReturnConfiguration(), "hs_");
    } else {
        auto scenarios = buildHistoricalScenarioGenerator(inputs_->historicalScenarioReader(), adjFactors, pnlDates,
                                                          analytic()->configurations().simMarketParams,
                                                          analytic()->configurations().todaysMarketParams);
    }
 
    auto simMarket = QuantLib::ext::make_shared<ScenarioSimMarket>(
        analytic()->market(), analytic()->configurations().simMarketParams, Market::defaultConfiguration,
        *analytic()->configurations().curveConfig, *analytic()->configurations().todaysMarketParams, true, true,
        false, false, *inputs_->iborFallbackConfig());
    simMarket->scenarioGenerator() = scenarios;
    scenarios->baseScenario() = simMarket->baseScenario();
 
    ext::shared_ptr<ScenarioShiftCalculator> shiftCalculator = ext::make_shared<ScenarioShiftCalculator>(
        analytic()->configurations().sensiScenarioData, analytic()->configurations().simMarketParams);
 
    std::unique_ptr<MarketRiskReport::SensiRunArgs> sensiArgs =
        std::make_unique<MarketRiskReport::SensiRunArgs>(ss, shiftCalculator);
 
    auto pnlExplainReport =
        ext::make_shared<PnlExplainReport>(inputs_->baseCurrency(), analytic()->portfolio(), inputs_->portfolioFilter(),
                                           period, pnlReport, scenarios, std::move(sensiArgs), nullptr, nullptr, true);
 
    LOG("Call PNL Explain calculation");
    CONSOLEW("Risk: PNL Explain Calculation");
    ext::shared_ptr<MarketRiskReport::Reports> reports = ext::make_shared<MarketRiskReport::Reports>();
    QuantLib::ext::shared_ptr<InMemoryReport> pnlExplainOutput = QuantLib::ext::make_shared<InMemoryReport>();
    reports->add(pnlReport);
 
    pnlExplainReport->calculate(reports);
    analytic()->reports()[label_]["pnl"] = pnlReport;
    analytic()->reports()[label_]["pnl_explain"] = pnlReport;
}

Here is the call graph for this function:

setUpConfigurations()

void setUpConfigurations ( )

overridevirtual

Reimplemented from Analytic::Impl.

Definition at line 34 of file pnlexplainanalytic.cpp.

                                                 {
    analytic()->configurations().simulationConfigRequired = true;
    analytic()->configurations().sensitivityConfigRequired = true;
    analytic()->configurations().todaysMarketParams = inputs_->todaysMarketParams();
    analytic()->configurations().simMarketParams = inputs_->scenarioSimMarketParams();
    analytic()->configurations().sensiScenarioData = inputs_->sensiScenarioData();
}

Here is the call graph for this function:

Member Data Documentation

LABEL

constexpr const char* LABEL = "PNL_EXPLAIN"

staticconstexpr

Definition at line 35 of file pnlexplainanalytic.hpp.

sensiLookupKey

constexpr const char* sensiLookupKey = "SENSI"

staticconstexpr

Definition at line 36 of file pnlexplainanalytic.hpp.

pnlLookupKey

constexpr const char* pnlLookupKey = "PNL"

staticconstexpr

Definition at line 37 of file pnlexplainanalytic.hpp.