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

Inheritance diagram for ScenarioStatisticsAnalyticImpl:

Collaboration diagram for ScenarioStatisticsAnalyticImpl:

Public Member Functions
	ScenarioStatisticsAnalyticImpl (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

void	setUpConfigurations () override

QuantLib::ext::shared_ptr< ScenarioGenerator >	scenarioGenerator ()

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 = "SCENARIO_STATISTICS"

Protected Member Functions
void	buildScenarioSimMarket ()

void	buildCrossAssetModel (bool continueOnError)

void	buildScenarioGenerator (bool continueOnError)

Protected Attributes
QuantLib::ext::shared_ptr< ScenarioSimMarket >	simMarket_

QuantLib::ext::shared_ptr< CrossAssetModel >	model_

QuantLib::ext::shared_ptr< ScenarioGenerator >	scenarioGenerator_

QuantLib::ext::shared_ptr< DateGrid >	grid_

Size	samples_ = 0

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 30 of file scenariostatisticsanalytic.hpp.

Constructor & Destructor Documentation

◆ ScenarioStatisticsAnalyticImpl()

ScenarioStatisticsAnalyticImpl ( const QuantLib::ext::shared_ptr< InputParameters > & inputs )

Definition at line 34 of file scenariostatisticsanalytic.hpp.

34: Analytic::Impl(inputs) { setLabel(LABEL); }

ore::analytics::Analytic::Impl::setLabel

void setLabel(const string &label)

Definition: analytic.hpp:189

ore::analytics::ScenarioStatisticsAnalyticImpl::LABEL

static constexpr const char * LABEL

Definition: scenariostatisticsanalytic.hpp:32

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 100 of file scenariostatisticsanalytic.cpp.

                                                                     {
 
    LOG("Scenario analytic called with asof " << io::iso_date(inputs_->asof()));
 
    Settings::instance().evaluationDate() = inputs_->asof();
    //ObservationMode::instance().setMode(inputs_->exposureObservationModel());
 
    LOG("SCENARIO_STATISTICS: Build Today's Market");
    CONSOLEW("SCENARIO_STATISTICS: Build Market");
    analytic()->buildMarket(loader);
    CONSOLE("OK");
 
    grid_ = analytic()->configurations().scenarioGeneratorData->getGrid();
 
    LOG("SCENARIO_STATISTICS: Build simulation market");
    buildScenarioSimMarket();
 
    LOG("SCENARIO_STATISTICS: Build Scenario Generator");
    auto globalParams = inputs_->simulationPricingEngine()->globalParameters();
    auto continueOnCalErr = globalParams.find("ContinueOnCalibrationError");
    bool continueOnErr = (continueOnCalErr != globalParams.end()) && parseBool(continueOnCalErr->second);
    buildScenarioGenerator(continueOnErr);
 
    LOG("SCENARIO_STATISTICS: Attach Scenario Generator to ScenarioSimMarket");
    simMarket_->scenarioGenerator() = scenarioGenerator_;
 
    MEM_LOG;
 
    // Output scenario statistics and distribution reports
    const vector<RiskFactorKey>& keys = simMarket_->baseScenario()->keys();
    QuantLib::ext::shared_ptr<ScenarioGenerator> scenarioGenerator =
    inputs_->scenarioOutputZeroRate()
        ? QuantLib::ext::make_shared<ScenarioGeneratorTransform>(scenarioGenerator_, simMarket_,
                                                            analytic()->configurations().simMarketParams)
        : scenarioGenerator_;
 
        auto statsReport = QuantLib::ext::make_shared<InMemoryReport>();
    scenarioGenerator->reset();
        ReportWriter().writeScenarioStatistics(scenarioGenerator, keys, samples_, grid_->valuationDates(),
                                               *statsReport);
    analytic()->reports()["SCENARIO_STATISTICS"]["scenario_statistics"] = statsReport;
 
    auto distributionReport = QuantLib::ext::make_shared<InMemoryReport>();
    scenarioGenerator->reset();
    ReportWriter().writeScenarioDistributions(scenarioGenerator, keys, samples_, grid_->valuationDates(),
                                              inputs_->scenarioDistributionSteps(), *distributionReport);
    analytic()->reports()["SCENARIO_STATISTICS"]["scenario_distribution"] = distributionReport;
}

Here is the call graph for this function:

◆ setUpConfigurations()

void setUpConfigurations ( )

overridevirtual

Reimplemented from Analytic::Impl.

Definition at line 41 of file scenariostatisticsanalytic.cpp.

                                                         {
    LOG("ScenarioStatisticsAnalytic::setUpConfigurations() called");
    analytic()->configurations().todaysMarketParams = inputs_->todaysMarketParams();
    analytic()->configurations().simMarketParams = inputs_->exposureSimMarketParams();
    analytic()->configurations().scenarioGeneratorData = inputs_->scenarioGeneratorData();
    analytic()->configurations().crossAssetModelData = inputs_->crossAssetModelData();
}

Here is the call graph for this function:

◆ scenarioGenerator()

QuantLib::ext::shared_ptr< ScenarioGenerator > scenarioGenerator ( )

Definition at line 39 of file scenariostatisticsanalytic.hpp.

39{ return scenarioGenerator_; }

Here is the caller graph for this function:

◆ buildScenarioSimMarket()

void buildScenarioSimMarket ( )

protected

Definition at line 49 of file scenariostatisticsanalytic.cpp.

                                                            {
    
    std::string configuration = inputs_->marketConfig("simulation");
    simMarket_ = QuantLib::ext::make_shared<ScenarioSimMarket>(
            analytic()->market(),
            analytic()->configurations().simMarketParams,
            QuantLib::ext::make_shared<FixingManager>(inputs_->asof()),
            configuration,
            *inputs_->curveConfigs().get(),
            *analytic()->configurations().todaysMarketParams,
            inputs_->continueOnError(), 
            false, true, false,
            *inputs_->iborFallbackConfig(),
            false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildCrossAssetModel()

void buildCrossAssetModel ( bool continueOnError )

protected

Definition at line 87 of file scenariostatisticsanalytic.cpp.

                                                                                               {
    LOG("SCENARIO_STATISTICS: Build Simulation Model (continueOnCalibrationError = "
        << std::boolalpha << continueOnCalibrationError << ")");
    CrossAssetModelBuilder modelBuilder(
        analytic()->market(), analytic()->configurations().crossAssetModelData, inputs_->marketConfig("lgmcalibration"),
        inputs_->marketConfig("fxcalibration"), inputs_->marketConfig("eqcalibration"),
        inputs_->marketConfig("infcalibration"), inputs_->marketConfig("crcalibration"),
        inputs_->marketConfig("simulation"), false, continueOnCalibrationError, "",
        inputs_->salvageCorrelationMatrix() ? SalvagingAlgorithm::Spectral : SalvagingAlgorithm::None,
        "xva cam building");
    model_ = *modelBuilder.model();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildScenarioGenerator()

void buildScenarioGenerator ( bool continueOnError )

protected

Definition at line 65 of file scenariostatisticsanalytic.cpp.

                                                                                                 {
    if (!model_)
        buildCrossAssetModel(continueOnCalibrationError);
    ScenarioGeneratorBuilder sgb(analytic()->configurations().scenarioGeneratorData);
    QuantLib::ext::shared_ptr<ScenarioFactory> sf = QuantLib::ext::make_shared<SimpleScenarioFactory>(true);
    string config = inputs_->marketConfig("simulation");
    scenarioGenerator_ = sgb.build(model_, sf, analytic()->configurations().simMarketParams, inputs_->asof(), analytic()->market(), config); 
    QL_REQUIRE(scenarioGenerator_, "failed to build the scenario generator"); 
    samples_ = analytic()->configurations().scenarioGeneratorData->samples();
    LOG("simulation grid size " << grid_->size());
    LOG("simulation grid valuation dates " << grid_->valuationDates().size());
    LOG("simulation grid close-out dates " << grid_->closeOutDates().size());
    LOG("simulation grid front date " << io::iso_date(grid_->dates().front()));    
    LOG("simulation grid back date " << io::iso_date(grid_->dates().back()));    
 
    if (inputs_->writeScenarios()) {
        auto report = QuantLib::ext::make_shared<InMemoryReport>();
        analytic()->reports()["SCENARIO_STATISTICS"]["scenario"] = report;
        scenarioGenerator_ = QuantLib::ext::make_shared<ScenarioWriter>(scenarioGenerator_, report);
    }
}