AMC Valuation Engine. More...

#include <orea/engine/amcvaluationengine.hpp>

Inheritance diagram for AMCValuationEngine:

Collaboration diagram for AMCValuationEngine:

Public Member Functions
	AMCValuationEngine (const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &model, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioGeneratorData > &scenarioGeneratorData, const QuantLib::ext::shared_ptr< ore::data::Market > &market, const std::vector< string > &aggDataIndices, const std::vector< string > &aggDataCurrencies, const Size aggDataNumberCreditStates)
	Constructor for single-threaded runs. More...

	AMCValuationEngine (const QuantLib::Size nThreads, const QuantLib::Date &today, const QuantLib::Size nSamples, const QuantLib::ext::shared_ptr< ore::data::Loader > &loader, const QuantLib::ext::shared_ptr< ScenarioGeneratorData > &scenarioGeneratorData, const std::vector< string > &aggDataIndices, const std::vector< string > &aggDataCurrencies, const Size aggDataNumberCreditStates, const QuantLib::ext::shared_ptr< CrossAssetModelData > &crossAssetModelData, const QuantLib::ext::shared_ptr< ore::data::EngineData > &engineData, const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &curveConfigs, const QuantLib::ext::shared_ptr< ore::data::TodaysMarketParameters > &todaysMarketParams, const std::string &configurationLgmCalibration, const std::string &configurationFxCalibration, const std::string &configurationEqCalibration, const std::string &configurationInfCalibration, const std::string &configurationCrCalibration, const std::string &configurationFinalModel, const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &referenceData=nullptr, const ore::data::IborFallbackConfig &iborFallbackConfig=ore::data::IborFallbackConfig::defaultConfig(), const bool handlePseudoCurrenciesTodaysMarket=true, const std::function< QuantLib::ext::shared_ptr< ore::analytics::NPVCube >(const QuantLib::Date &, const std::set< std::string > &, const std::vector< QuantLib::Date > &, const QuantLib::Size)> &cubeFactory={}, const QuantLib::ext::shared_ptr< Scenario > &offSetScenario=nullptr, const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &simMarketParams=nullptr)
	Constructor for multi threaded runs. More...

void	buildCube (const QuantLib::ext::shared_ptr< ore::data::Portfolio > &portfolio, QuantLib::ext::shared_ptr< ore::analytics::NPVCube > &outputCube)
	build cube in single threaded run More...

void	buildCube (const QuantLib::ext::shared_ptr< ore::data::Portfolio > &portfolio)
	build cube in multi threaded run More...

std::vector< QuantLib::ext::shared_ptr< ore::analytics::NPVCube > >	outputCubes () const

QuantLib::ext::shared_ptr< ore::analytics::AggregationScenarioData > &	aggregationScenarioData ()
	Set aggregation data. More...

const QuantLib::ext::shared_ptr< ore::analytics::AggregationScenarioData > &	aggregationScenarioData () const
	Get aggregation data. 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 Attributes
QuantLib::ext::shared_ptr< ore::analytics::AggregationScenarioData >	asd_

bool	useMultithreading_ = false

const std::vector< string >	aggDataIndices_

const std::vector< string >	aggDataCurrencies_

const Size	aggDataNumberCreditStates_

QuantLib::ext::shared_ptr< ScenarioGeneratorData >	scenarioGeneratorData_

const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel >	model_

const QuantLib::ext::shared_ptr< ore::data::Market >	market_

QuantLib::Size	nThreads_

QuantLib::Date	today_

QuantLib::Size	nSamples_

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

QuantLib::ext::shared_ptr< CrossAssetModelData >	crossAssetModelData_

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

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

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

std::string	configurationLgmCalibration_

std::string	configurationFxCalibration_

std::string	configurationEqCalibration_

std::string	configurationInfCalibration_

std::string	configurationCrCalibration_

std::string	configurationFinalModel_

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

ore::data::IborFallbackConfig	iborFallbackConfig_

bool	handlePseudoCurrenciesTodaysMarket_

std::function< QuantLib::ext::shared_ptr< ore::analytics::NPVCube >(const QuantLib::Date &, const std::set< std::string > &, const std::vector< QuantLib::Date > &, const QuantLib::Size)>	cubeFactory_

QuantLib::ext::shared_ptr< Scenario >	offsetScenario_

QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters >	simMarketParams_

std::vector< QuantLib::ext::shared_ptr< ore::analytics::NPVCube > >	miniCubes_

Detailed Description

AMC Valuation Engine.

Definition at line 42 of file amcvaluationengine.hpp.

Constructor & Destructor Documentation

◆ AMCValuationEngine() [1/2]

AMCValuationEngine	(	const QuantLib::ext::shared_ptr< QuantExt::CrossAssetModel > &	model,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioGeneratorData > &	scenarioGeneratorData,
		const QuantLib::ext::shared_ptr< ore::data::Market > &	market,
		const std::vector< string > &	aggDataIndices,
		const std::vector< string > &	aggDataCurrencies,
		const Size	aggDataNumberCreditStates
	)

Constructor for single-threaded runs.

◆ AMCValuationEngine() [2/2]

AMCValuationEngine	(	const QuantLib::Size	nThreads,
		const QuantLib::Date &	today,
		const QuantLib::Size	nSamples,
		const QuantLib::ext::shared_ptr< ore::data::Loader > &	loader,
		const QuantLib::ext::shared_ptr< ScenarioGeneratorData > &	scenarioGeneratorData,
		const std::vector< string > &	aggDataIndices,
		const std::vector< string > &	aggDataCurrencies,
		const Size	aggDataNumberCreditStates,
		const QuantLib::ext::shared_ptr< CrossAssetModelData > &	crossAssetModelData,
		const QuantLib::ext::shared_ptr< ore::data::EngineData > &	engineData,
		const QuantLib::ext::shared_ptr< ore::data::CurveConfigurations > &	curveConfigs,
		const QuantLib::ext::shared_ptr< ore::data::TodaysMarketParameters > &	todaysMarketParams,
		const std::string &	configurationLgmCalibration,
		const std::string &	configurationFxCalibration,
		const std::string &	configurationEqCalibration,
		const std::string &	configurationInfCalibration,
		const std::string &	configurationCrCalibration,
		const std::string &	configurationFinalModel,
		const QuantLib::ext::shared_ptr< ore::data::ReferenceDataManager > &	referenceData = `nullptr`,
		const ore::data::IborFallbackConfig &	iborFallbackConfig = `ore::data::IborFallbackConfig::defaultConfig()`,
		const bool	handlePseudoCurrenciesTodaysMarket = `true`,
		const std::function< QuantLib::ext::shared_ptr< ore::analytics::NPVCube >(const QuantLib::Date &, const std::set< std::string > &, const std::vector< QuantLib::Date > &, const QuantLib::Size)> &	cubeFactory = `{}`,
		const QuantLib::ext::shared_ptr< Scenario > &	offSetScenario = `nullptr`,
		const QuantLib::ext::shared_ptr< ore::analytics::ScenarioSimMarketParameters > &	simMarketParams = `nullptr`
	)

Constructor for multi threaded runs.

Definition at line 604 of file amcvaluationengine.cpp.

    : useMultithreading_(true), aggDataIndices_(aggDataIndices), aggDataCurrencies_(aggDataCurrencies),
      aggDataNumberCreditStates_(aggDataNumberCreditStates), scenarioGeneratorData_(scenarioGeneratorData),
      nThreads_(nThreads), today_(today), nSamples_(nSamples), loader_(loader),
      crossAssetModelData_(crossAssetModelData), engineData_(engineData), curveConfigs_(curveConfigs),
      todaysMarketParams_(todaysMarketParams), configurationLgmCalibration_(configurationLgmCalibration),
      configurationFxCalibration_(configurationFxCalibration), configurationEqCalibration_(configurationEqCalibration),
      configurationInfCalibration_(configurationInfCalibration),
      configurationCrCalibration_(configurationCrCalibration), configurationFinalModel_(configurationFinalModel),
      referenceData_(referenceData), iborFallbackConfig_(iborFallbackConfig),
      handlePseudoCurrenciesTodaysMarket_(handlePseudoCurrenciesTodaysMarket), cubeFactory_(cubeFactory),
      offsetScenario_(offSetScenario), simMarketParams_(simMarketParams) {
#ifndef QL_ENABLE_SESSIONS
    QL_FAIL(
        "AMCValuationEngine requires a build with QL_ENABLE_SESSIONS = ON when ctor multi-threaded runs is called.");
#endif
    QL_REQUIRE(scenarioGeneratorData_->seed() != 0,
               "AMCValuationEngine: path generation uses seed 0 - this might lead to inconsistent results to a classic "
               "simulation run, if both are combined. Consider using a non-zero seed.");
    if (!cubeFactory_)
        cubeFactory_ = [](const QuantLib::Date& asof, const std::set<std::string>& ids,
                          const std::vector<QuantLib::Date>& dates, const Size samples) {
            return QuantLib::ext::make_shared<ore::analytics::DoublePrecisionInMemoryCube>(asof, ids, dates, samples);
        };
}

Here is the call graph for this function:

Member Function Documentation

◆ buildCube() [1/2]

void buildCube	(	const QuantLib::ext::shared_ptr< ore::data::Portfolio > &	portfolio,
		QuantLib::ext::shared_ptr< ore::analytics::NPVCube > &	outputCube
	)

build cube in single threaded run

Here is the caller graph for this function:

◆ buildCube() [2/2]

void buildCube ( const QuantLib::ext::shared_ptr< ore::data::Portfolio > & portfolio )

build cube in multi threaded run

Definition at line 704 of file amcvaluationengine.cpp.

                                                                                           {
    LOG("Starting multi-threaded AMCValuationEngine for "
        << portfolio->size() << " trades, " << nSamples_ << " samples and " << scenarioGeneratorData_->getGrid()->size()
        << " dates.");
 
    QL_REQUIRE(useMultithreading_, "AMCValuationEngine::buildCube() method was called with signature for "
                                   "multi-threaded run, but engine was constructed for single-threaded runs");
 
    QL_REQUIRE(portfolio->size() > 0, "AMCValuationEngine::buildCube: empty portfolio");
 
    // split portfolio into nThreads parts (just distribute the trades assuming all are approximately expensive)
 
    LOG("Splitting portfolio.");
 
    Size eff_nThreads = std::min(portfolio->size(), nThreads_);
 
    LOG("portfolio size = " << portfolio->size());
    LOG("nThreads       = " << nThreads_);
    LOG("eff nThreads   = " << eff_nThreads);
 
    QL_REQUIRE(eff_nThreads > 0, "effective threads are zero, this is not allowed.");
 
    std::vector<QuantLib::ext::shared_ptr<ore::data::Portfolio>> portfolios;
    for (Size i = 0; i < eff_nThreads; ++i)
        portfolios.push_back(QuantLib::ext::make_shared<ore::data::Portfolio>());
 
    Size portfolioIndex = 0;
    for (auto const& t : portfolio->trades()) {
        portfolios[portfolioIndex]->add(t.second);
        if (++portfolioIndex >= eff_nThreads)
            portfolioIndex = 0;
    }
 
    // output the portfolios into strings so that the worker threads can load them from there
 
    std::vector<std::string> portfoliosAsString;
    for (auto const& p : portfolios) {
        portfoliosAsString.emplace_back(p->toXMLString());
    }
 
    // log info on the portfolio split
 
    for (Size i = 0; i < eff_nThreads; ++i) {
        LOG("Portfolio #" << i << " number of trades       : " << portfolios[i]->size());
    }
 
    // build loaders for each thread as clones of the original one
 
    LOG("Cloning loaders for " << eff_nThreads << " threads...");
    std::vector<QuantLib::ext::shared_ptr<ore::data::ClonedLoader>> loaders;
    for (Size i = 0; i < eff_nThreads; ++i)
        loaders.push_back(QuantLib::ext::make_shared<ore::data::ClonedLoader>(today_, loader_));
 
    // build nThreads mini-cubes to which each thread writes its results
 
    LOG("Build " << eff_nThreads << " mini result cubes...");
    miniCubes_.clear();
    for (Size i = 0; i < eff_nThreads; ++i) {
        miniCubes_.push_back(
            cubeFactory_(today_, portfolios[i]->ids(), scenarioGeneratorData_->getGrid()->valuationDates(), nSamples_));
    }
 
    // precompute sim dates
 
    std::vector<Date> simDates =
        scenarioGeneratorData_->withCloseOutLag() && !scenarioGeneratorData_->withMporStickyDate()
            ? scenarioGeneratorData_->getGrid()->dates()
            : scenarioGeneratorData_->getGrid()->valuationDates();
 
    // build progress indicator consolidating the results from the threads
 
    auto progressIndicator =
        QuantLib::ext::make_shared<ore::analytics::MultiThreadedProgressIndicator>(this->progressIndicators());
 
    // create the thread pool with eff_nThreads and queue size = eff_nThreads as well
 
    // LOG("Create thread pool with " << eff_nThreads);
    // ctpl::thread_pool threadPool(eff_nThreads);
 
    // create the jobs and push them to the pool
 
    using resultType = int;
    std::vector<std::future<resultType>> results(eff_nThreads);
 
    std::vector<std::thread> jobs; // not needed if thread pool is used
 
    // get obs mode of main thread, so that we can set this mode in the worker threads below
 
    ore::analytics::ObservationMode::Mode obsMode = ore::analytics::ObservationMode::instance().mode();
 
    for (Size i = 0; i < eff_nThreads; ++i) {
 
        auto job = [this, obsMode, &portfoliosAsString, &loaders, &simDates, &progressIndicator](int id) -> resultType {
            // set thread local singletons
 
            QuantLib::Settings::instance().evaluationDate() = today_;
            ore::analytics::ObservationMode::instance().setMode(obsMode);
 
            LOG("Start thread " << id);
 
            int rc;
 
            try {
 
                // build todays market using cloned market data
 
                QuantLib::ext::shared_ptr<ore::data::Market> initMarket = QuantLib::ext::make_shared<ore::data::TodaysMarket>(
                    today_, todaysMarketParams_, loaders[id], curveConfigs_, true, true, true, referenceData_, false,
                    iborFallbackConfig_, false, handlePseudoCurrenciesTodaysMarket_);
 
                QuantLib::ext::shared_ptr<ore::data::Market> market = initMarket;
 
                if(offsetScenario_ != nullptr){
                    QL_REQUIRE(simMarketParams_ != nullptr,
                               "AMC Valuation Engine can not build simMarket without simMarketParam");
                    bool continueOnError = true;
                    std::string configuration = configurationFinalModel_;
                    market = QuantLib::ext::make_shared<ScenarioSimMarket>(
                        initMarket, simMarketParams_, QuantLib::ext::make_shared<FixingManager>(today_), configuration,
                        *curveConfigs_, *todaysMarketParams_, continueOnError, true, true, false, iborFallbackConfig_,
                        false, offsetScenario_);
                }
 
                // build cam
                ore::data::CrossAssetModelBuilder modelBuilder(
                    market, crossAssetModelData_, configurationLgmCalibration_, configurationFxCalibration_,
                    configurationEqCalibration_, configurationInfCalibration_, configurationCrCalibration_,
                    configurationFinalModel_, false, true, "", SalvagingAlgorithm::None, "xva/amc cam building");
 
                auto cam = *modelBuilder.model();
 
                // build portfolio against init market
 
                auto portfolio = QuantLib::ext::make_shared<ore::data::Portfolio>();
                portfolio->fromXMLString(portfoliosAsString[id]);
 
                QuantLib::ext::shared_ptr<EngineData> edCopy = QuantLib::ext::make_shared<EngineData>(*engineData_);
                edCopy->globalParameters()["GenerateAdditionalResults"] = "false";
                edCopy->globalParameters()["RunType"] = "NPV";
                map<MarketContext, string> configurations{{MarketContext::irCalibration, configurationLgmCalibration_},
                                                          {MarketContext::fxCalibration, configurationFxCalibration_},
                                                          {MarketContext::pricing, configurationFinalModel_}};
 
                auto engineFactory = QuantLib::ext::make_shared<EngineFactory>(
                    edCopy, market, configurations, referenceData_, iborFallbackConfig_,
                    EngineBuilderFactory::instance().generateAmcEngineBuilders(cam, simDates), true);
 
                portfolio->build(engineFactory, "amc-val-engine", true);
 
                // run core engine code (asd is written for thread id 0 only)
 
                runCoreEngine(portfolio, cam, market, scenarioGeneratorData_, aggDataIndices_, aggDataCurrencies_,
                              aggDataNumberCreditStates_, id == 0 ? asd_ : nullptr, miniCubes_[id], progressIndicator);
 
                // return code 0 = ok
 
                LOG("Thread " << id << " successfully finished.");
 
                rc = 0;
 
            } catch (const std::exception& e) {
 
                // log error and return code 1 = not ok
 
                ore::analytics::StructuredAnalyticsErrorMessage("AMC Valuation Engine (multithreaded mode)", "",
                                                                e.what())
                    .log();
                rc = 1;
            }
 
            // exit
 
            return rc;
        };
 
        // results[i] = threadPool.push(job);
 
        // not needed if thread pool is used
        std::packaged_task<resultType(int)> task(job);
        results[i] = task.get_future();
        std::thread thread(std::move(task), i);
        jobs.emplace_back(std::move(thread));
    }
 
    // not needed if thread pool is used
    for (auto& t : jobs)
        t.join();
 
    for (Size i = 0; i < results.size(); ++i) {
        results[i].wait();
    }
 
    for (Size i = 0; i < results.size(); ++i) {
        QL_REQUIRE(results[i].valid(), "internal error: did not get a valid result");
        int rc = results[i].get();
        QL_REQUIRE(rc == 0, "error: thread " << i << " exited with return code " << rc
                                             << ". Check for structured errors from 'AMCValuationEngine'.");
    }
 
    // stop the thread pool, wait for unfinished jobs
 
    // LOG("Stop thread pool");
    // threadPool.stop(true);
 
    LOG("Finished multi-threaded AMCValuationEngine run.");
}

Here is the call graph for this function:

◆ outputCubes()

std::vector< QuantLib::ext::shared_ptr< ore::analytics::NPVCube > > outputCubes ( ) const

Definition at line 80 of file amcvaluationengine.hpp.

80{ return miniCubes_; }

Here is the caller graph for this function:

◆ aggregationScenarioData() [1/2]

QuantLib::ext::shared_ptr< ore::analytics::AggregationScenarioData > & aggregationScenarioData ( )

Set aggregation data.

Definition at line 83 of file amcvaluationengine.hpp.

83{ return asd_; }

Here is the caller graph for this function:

◆ aggregationScenarioData() [2/2]

const QuantLib::ext::shared_ptr< ore::analytics::AggregationScenarioData > & aggregationScenarioData ( ) const

Get aggregation data.

Definition at line 86 of file amcvaluationengine.hpp.

86{ return asd_; }

Member Data Documentation

◆ asd_

QuantLib::ext::shared_ptr<ore::analytics::AggregationScenarioData> asd_

private

Definition at line 90 of file amcvaluationengine.hpp.

◆ useMultithreading_

bool useMultithreading_ = false

private

Definition at line 93 of file amcvaluationengine.hpp.

◆ aggDataIndices_

const std::vector<string> aggDataIndices_

private

Definition at line 96 of file amcvaluationengine.hpp.

◆ aggDataCurrencies_

const std::vector<string> aggDataCurrencies_

private

Definition at line 96 of file amcvaluationengine.hpp.

◆ aggDataNumberCreditStates_

const Size aggDataNumberCreditStates_

private

Definition at line 97 of file amcvaluationengine.hpp.

◆ scenarioGeneratorData_

QuantLib::ext::shared_ptr<ScenarioGeneratorData> scenarioGeneratorData_

private

Definition at line 98 of file amcvaluationengine.hpp.

◆ model_

const QuantLib::ext::shared_ptr<QuantExt::CrossAssetModel> model_

private

Definition at line 101 of file amcvaluationengine.hpp.

◆ market_

const QuantLib::ext::shared_ptr<ore::data::Market> market_

private

Definition at line 102 of file amcvaluationengine.hpp.

◆ nThreads_

QuantLib::Size nThreads_

private

Definition at line 105 of file amcvaluationengine.hpp.

◆ today_

QuantLib::Date today_

private

Definition at line 106 of file amcvaluationengine.hpp.

◆ nSamples_

QuantLib::Size nSamples_

private

Definition at line 107 of file amcvaluationengine.hpp.

◆ loader_

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

private

Definition at line 108 of file amcvaluationengine.hpp.

◆ crossAssetModelData_

QuantLib::ext::shared_ptr<CrossAssetModelData> crossAssetModelData_

private

Definition at line 109 of file amcvaluationengine.hpp.

◆ engineData_

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

private

Definition at line 110 of file amcvaluationengine.hpp.

◆ curveConfigs_

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

private

Definition at line 111 of file amcvaluationengine.hpp.

◆ todaysMarketParams_

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

private

Definition at line 112 of file amcvaluationengine.hpp.

◆ configurationLgmCalibration_

std::string configurationLgmCalibration_

private

Definition at line 113 of file amcvaluationengine.hpp.

◆ configurationFxCalibration_

std::string configurationFxCalibration_

private

Definition at line 114 of file amcvaluationengine.hpp.

◆ configurationEqCalibration_

std::string configurationEqCalibration_

private

Definition at line 115 of file amcvaluationengine.hpp.

◆ configurationInfCalibration_

std::string configurationInfCalibration_

private

Definition at line 116 of file amcvaluationengine.hpp.

◆ configurationCrCalibration_

std::string configurationCrCalibration_

private

Definition at line 117 of file amcvaluationengine.hpp.

◆ configurationFinalModel_

std::string configurationFinalModel_

private

Definition at line 118 of file amcvaluationengine.hpp.

◆ referenceData_

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

private

Definition at line 119 of file amcvaluationengine.hpp.

◆ iborFallbackConfig_

ore::data::IborFallbackConfig iborFallbackConfig_

private

Definition at line 120 of file amcvaluationengine.hpp.

◆ handlePseudoCurrenciesTodaysMarket_

bool handlePseudoCurrenciesTodaysMarket_

private

Definition at line 121 of file amcvaluationengine.hpp.

◆ cubeFactory_

std::function<QuantLib::ext::shared_ptr<ore::analytics::NPVCube>(const QuantLib::Date&, const std::set<std::string>&, const std::vector<QuantLib::Date>&, const QuantLib::Size)> cubeFactory_

private

Definition at line 124 of file amcvaluationengine.hpp.

◆ offsetScenario_

QuantLib::ext::shared_ptr<Scenario> offsetScenario_

private

Definition at line 125 of file amcvaluationengine.hpp.

◆ simMarketParams_

QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarketParameters> simMarketParams_

private

Definition at line 126 of file amcvaluationengine.hpp.

◆ miniCubes_

std::vector<QuantLib::ext::shared_ptr<ore::analytics::NPVCube> > miniCubes_

private

Definition at line 128 of file amcvaluationengine.hpp.

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AMCValuationEngine() [1/2]

◆ AMCValuationEngine() [2/2]

Member Function Documentation

◆ buildCube() [1/2]

◆ buildCube() [2/2]

◆ outputCubes()

◆ aggregationScenarioData() [1/2]

◆ aggregationScenarioData() [2/2]

Member Data Documentation

◆ asd_

◆ useMultithreading_

◆ aggDataIndices_

◆ aggDataCurrencies_

◆ aggDataNumberCreditStates_

◆ scenarioGeneratorData_

◆ model_

◆ market_

◆ nThreads_

◆ today_

◆ nSamples_

◆ loader_

◆ crossAssetModelData_

◆ engineData_

◆ curveConfigs_

◆ todaysMarketParams_

◆ configurationLgmCalibration_

◆ configurationFxCalibration_

◆ configurationEqCalibration_

◆ configurationInfCalibration_

◆ configurationCrCalibration_

◆ configurationFinalModel_

◆ referenceData_

◆ iborFallbackConfig_

◆ handlePseudoCurrenciesTodaysMarket_

◆ cubeFactory_

◆ offsetScenario_

◆ simMarketParams_

◆ miniCubes_