Merge remote-tracking branch 'origin/master' into QPR-11548

Author: pcaspers

OREAnalytics/orea/aggregation/dimcalculator.cpp

@@ -19,10 +19,11 @@
 #include <orea/aggregation/dimcalculator.hpp>
 #include <ored/utilities/log.hpp>
 #include <ored/utilities/vectorutils.hpp>
+#include <ored/portfolio/trade.hpp>
+
 #include <ql/errors.hpp>
 #include <ql/time/calendars/weekendsonly.hpp>
 #include <ql/version.hpp>
-
 #include <ql/math/distributions/normaldistribution.hpp>
 #include <ql/math/generallinearleastsquares.hpp>
 #include <ql/math/kernelfunctions.hpp>

OREAnalytics/orea/aggregation/exposureallocator.cpp

@@ -19,6 +19,8 @@
 #include <orea/aggregation/exposureallocator.hpp>
 #include <orea/cube/inmemorycube.hpp>
 
+#include <ored/portfolio/trade.hpp>
+
 using namespace std;
 using namespace QuantLib;
 

OREAnalytics/orea/aggregation/exposurecalculator.cpp

@@ -19,6 +19,8 @@
 #include <orea/aggregation/exposurecalculator.hpp>
 #include <orea/cube/inmemorycube.hpp>
 
+#include <ored/portfolio/trade.hpp>
+
 #include <ql/time/date.hpp>
 #include <ql/time/calendars/weekendsonly.hpp>
 

OREAnalytics/orea/aggregation/nettedexposurecalculator.cpp

@@ -18,6 +18,8 @@
 
 #include <orea/aggregation/nettedexposurecalculator.hpp>
 
+#include <ored/portfolio/trade.hpp>
+
 #include <ql/time/date.hpp>
 #include <ql/time/calendars/weekendsonly.hpp>
 

OREAnalytics/orea/aggregation/xvacalculator.cpp

@@ -17,8 +17,11 @@
 */
 
 #include <orea/aggregation/xvacalculator.hpp>
+
+#include <ored/portfolio/trade.hpp>
 #include <ored/utilities/log.hpp>
 #include <ored/utilities/vectorutils.hpp>
+
 #include <ql/errors.hpp>
 #include <ql/version.hpp>
 

OREAnalytics/orea/app/analytic.cpp

@@ -100,8 +100,8 @@ boost::shared_ptr<EngineFactory> Analytic::engineFactory() {
     configurations[MarketContext::pricing] = inputs_->marketConfig("pricing");
     LOG("MarketContext::pricing = " << inputs_->marketConfig("pricing"));
     //configurations[MarketContext::simulation] = inputs_->marketConfig("simulation");
-    return boost::make_shared<EngineFactory>(edCopy, market_, configurations, extraEngineBuilders, extraLegBuilders,
-                                             inputs_->refDataManager(), *inputs_->iborFallbackConfig());
+    return boost::make_shared<EngineFactory>(edCopy, market_, configurations, inputs_->refDataManager(),
+                                             *inputs_->iborFallbackConfig());
 }
 
 boost::shared_ptr<ore::data::EngineFactory> PricingAnalytic::engineFactory() {
@@ -117,8 +117,8 @@ boost::shared_ptr<ore::data::EngineFactory> PricingAnalytic::engineFactory() {
     //configurations[MarketContext::simulation] = inputs_->marketConfig("simulation");
     std::vector<boost::shared_ptr<ore::data::EngineBuilder>> extraBuilders;
     std::vector<boost::shared_ptr<ore::data::LegBuilder>> extraLegBuilders;
-    return boost::make_shared<EngineFactory>(edCopy, market_, configurations, extraBuilders, extraLegBuilders,
-                                             inputs_->refDataManager(), *inputs_->iborFallbackConfig());
+    return boost::make_shared<EngineFactory>(edCopy, market_, configurations, inputs_->refDataManager(),
+                                             *inputs_->iborFallbackConfig());
 }
 
 void Analytic::buildMarket(const boost::shared_ptr<ore::data::InMemoryLoader>& loader,
@@ -299,11 +299,10 @@ void PricingAnalytic::runAnalytic(const boost::shared_ptr<ore::data::InMemoryLoa
             std::string marketConfig = inputs_->marketConfig("pricing");
             std::vector<boost::shared_ptr<ore::data::EngineBuilder>> extraEngineBuilders;
             std::vector<boost::shared_ptr<ore::data::LegBuilder>> extraLegBuilders;
-	    boost::shared_ptr<StressTest> stressTest = boost::make_shared<StressTest>(
-                 portfolio_, market_, marketConfig, inputs_->pricingEngine(), inputs_->stressSimMarketParams(),
-                 inputs_->stressScenarioData(), *inputs_->curveConfigs().at(0),
-                 *configurations_.todaysMarketParams, nullptr, extraEngineBuilders, extraLegBuilders,
-                 inputs_->refDataManager(), *inputs_->iborFallbackConfig(), inputs_->continueOnError());
+            boost::shared_ptr<StressTest> stressTest = boost::make_shared<StressTest>(
+                portfolio_, market_, marketConfig, inputs_->pricingEngine(), inputs_->stressSimMarketParams(),
+                inputs_->stressScenarioData(), *inputs_->curveConfigs().at(0), *configurations_.todaysMarketParams,
+                nullptr, inputs_->refDataManager(), *inputs_->iborFallbackConfig(), inputs_->continueOnError());
             stressTest->writeReport(report, inputs_->stressThreshold());
             reports_[analytic]["stress"] = report;
             CONSOLE("OK");
@@ -320,11 +319,10 @@ void PricingAnalytic::runAnalytic(const boost::shared_ptr<ore::data::InMemoryLoa
                 std::vector<boost::shared_ptr<ore::data::EngineBuilder>> extraEngineBuilders;
                 std::vector<boost::shared_ptr<ore::data::LegBuilder>> extraLegBuilders;
                 sensiAnalysis = boost::make_shared<SensitivityAnalysisPlus>(
-                    portfolio_, market_, configuration, inputs_->pricingEngine(),
-                    configurations_.simMarketParams, configurations_.sensiScenarioData, recalibrateModels,
-                    inputs_->curveConfigs().at(0), configurations_.todaysMarketParams, ccyConv, extraEngineBuilders,
-                    extraLegBuilders, inputs_->refDataManager(), *inputs_->iborFallbackConfig(), true, false,
-                    inputs_->dryRun());
+                    portfolio_, market_, configuration, inputs_->pricingEngine(), configurations_.simMarketParams,
+                    configurations_.sensiScenarioData, recalibrateModels, inputs_->curveConfigs().at(0),
+                    configurations_.todaysMarketParams, ccyConv, inputs_->refDataManager(),
+                    *inputs_->iborFallbackConfig(), true, false, inputs_->dryRun());
                 LOG("Single-threaded sensi analysis created");
             }
             else {
@@ -338,8 +336,7 @@ void PricingAnalytic::runAnalytic(const boost::shared_ptr<ore::data::InMemoryLoa
                     inputs_->nThreads(), inputs_->asof(), loader, portfolio_, Market::defaultConfiguration,
                     inputs_->pricingEngine(), configurations_.simMarketParams, configurations_.sensiScenarioData,
                     recalibrateModels, inputs_->curveConfigs().at(0), configurations_.todaysMarketParams, ccyConv,
-                    extraTradeBuilders, extraEngineBuilders, extraLegBuilders, inputs_->refDataManager(),
-                    *inputs_->iborFallbackConfig(), true, false, inputs_->dryRun());
+                    inputs_->refDataManager(), *inputs_->iborFallbackConfig(), true, false, inputs_->dryRun());
                 LOG("Multi-threaded sensi analysis created");
             }
             // FIXME: Why are these disabled?
@@ -512,13 +509,11 @@ boost::shared_ptr<EngineFactory> XvaAnalytic::engineFactory() {
         // link to the sim market here
         QL_REQUIRE(simMarket_, "Simulaton market not set");
         engineFactory_ = boost::make_shared<EngineFactory>(edCopy, simMarket_, configurations,
-                                                 extraEngineBuilders, extraLegBuilders, inputs_->refDataManager(),
-                                                 *inputs_->iborFallbackConfig());
+                                                           inputs_->refDataManager(), *inputs_->iborFallbackConfig());
     } else {
         // we just link to today's market if simulation is not required
-        engineFactory_ = boost::make_shared<EngineFactory>(edCopy, market_, configurations,
-                                                 extraEngineBuilders, extraLegBuilders, inputs_->refDataManager(),
-                                                 *inputs_->iborFallbackConfig());        
+        engineFactory_ = boost::make_shared<EngineFactory>(edCopy, market_, configurations, inputs_->refDataManager(),
+                                                           *inputs_->iborFallbackConfig());
     }
     return engineFactory_;
 }
@@ -779,7 +774,7 @@ void XvaAnalytic::buildClassicCube(const boost::shared_ptr<Portfolio>& portfolio
             inputs_->nThreads(), inputs_->asof(), grid_, samples_, loader_, scenarioGenerator_,
             inputs_->simulationPricingEngine(), inputs_->curveConfigs()[0], configurations_.todaysMarketParams,
             inputs_->marketConfig("simulation"), configurations_.simMarketParams, false, false,
-            boost::make_shared<ore::analytics::ScenarioFilter>(), {}, {}, {}, inputs_->refDataManager(),
+            boost::make_shared<ore::analytics::ScenarioFilter>(), inputs_->refDataManager(),
             *inputs_->iborFallbackConfig(), true, false, cubeFactory, {}, cptyCubeFactory, "xva-simulation");
 
         if (ConsoleLog::instance().enabled())
@@ -804,22 +799,8 @@ void XvaAnalytic::buildClassicCube(const boost::shared_ptr<Portfolio>& portfolio
     Settings::instance().evaluationDate() = inputs_->asof();
 }
 
-
-std::vector<boost::shared_ptr<EngineBuilder>>
-getAmcEngineBuilders(const boost::shared_ptr<QuantExt::CrossAssetModel>& cam, const std::vector<Date>& grid) {
-    std::vector<boost::shared_ptr<EngineBuilder>> eb;
-    eb.push_back(boost::make_shared<data::CamAmcCurrencySwapEngineBuilder>(cam, grid));
-    eb.push_back(boost::make_shared<data::CamAmcFxOptionEngineBuilder>(cam, grid));
-    eb.push_back(boost::make_shared<data::CamAmcMultiLegOptionEngineBuilder>(cam, grid));
-    eb.push_back(boost::make_shared<data::CamAmcSwapEngineBuilder>(cam, grid));
-    eb.push_back(boost::make_shared<data::LgmAmcBermudanSwaptionEngineBuilder>(cam, grid));
-    // FIXME: Uncomment for release 10
-    // eb.push_back(boost::make_shared<data::ScriptedTradeEngineBuilder>(ScriptLibraryStorage::scriptLibrary, cam, grid));
-    return eb;
-}
-
-
-boost::shared_ptr<EngineFactory> XvaAnalytic::amcEngineFactory() {
+boost::shared_ptr<EngineFactory> XvaAnalytic::amcEngineFactory(const boost::shared_ptr<QuantExt::CrossAssetModel>& cam,
+                                                               const std::vector<Date>& grid) {
     LOG("XvaAnalytic::engineFactory() called");
     boost::shared_ptr<EngineData> edCopy = boost::make_shared<EngineData>(*inputs_->amcPricingEngine());
     edCopy->globalParameters()["GenerateAdditionalResults"] = inputs_->outputAdditionalResults() ? "true" : "false";
@@ -830,14 +811,12 @@ boost::shared_ptr<EngineFactory> XvaAnalytic::amcEngineFactory() {
     configurations[MarketContext::pricing] = inputs_->marketConfig("pricing");
     std::vector<boost::shared_ptr<EngineBuilder>> extraEngineBuilders; 
     std::vector<boost::shared_ptr<LegBuilder>> extraLegBuilders;
-    auto factory = boost::make_shared<EngineFactory>(edCopy, market_, configurations,
-                                                     extraEngineBuilders, extraLegBuilders,
-                                                     inputs_->refDataManager(),
-                                                     *inputs_->iborFallbackConfig());
+    auto factory = boost::make_shared<EngineFactory>(
+        edCopy, market_, configurations, inputs_->refDataManager(), *inputs_->iborFallbackConfig(),
+        EngineBuilderFactory::instance().generateAmcEngineBuilders(cam, grid), true);
     return factory;
 }
 
-
 void XvaAnalytic::buildAmcPortfolio() {
     LOG("XVA: buildAmcPortfolio");
     CONSOLEW("XVA: Build AMC portfolio");
@@ -846,14 +825,9 @@ void XvaAnalytic::buildAmcPortfolio() {
     std::vector<Date> simDates =
         configurations_.scenarioGeneratorData->withCloseOutLag() && !configurations_.scenarioGeneratorData->withMporStickyDate() ?
         configurations_.scenarioGeneratorData->getGrid()->dates() : configurations_.scenarioGeneratorData->getGrid()->valuationDates();
-
-    LOG("buildAmcPortfolio: Get engine builders");
-    auto eb = getAmcEngineBuilders(model_, simDates);
 
     LOG("buildAmcPortfolio: Register additional engine builders");
-    auto factory = amcEngineFactory();
-    for(auto const& b : eb)
-        factory->registerBuilder(b);
+    auto factory = amcEngineFactory(model_, simDates);
 
     LOG("buildAmcPortfolio: Load Portfolio");
     boost::shared_ptr<Portfolio> portfolio = inputs_->portfolio();
@@ -928,8 +902,8 @@ void XvaAnalytic::amcRun(bool doClassicRun) {
             inputs_->amcPricingEngine(), inputs_->curveConfigs()[0], configurations_.todaysMarketParams,
             inputs_->marketConfig("lgmcalibration"), inputs_->marketConfig("fxcalibration"),
             inputs_->marketConfig("eqcalibration"), inputs_->marketConfig("infcalibration"),
-            inputs_->marketConfig("crcalibration"), inputs_->marketConfig("simulation"), getAmcEngineBuilders, {}, {},
-            inputs_->refDataManager(), *inputs_->iborFallbackConfig(), true, cubeFactory);
+            inputs_->marketConfig("crcalibration"), inputs_->marketConfig("simulation"), inputs_->refDataManager(),
+            *inputs_->iborFallbackConfig(), true, cubeFactory);
         if (ConsoleLog::instance().enabled())
             amcEngine.registerProgressIndicator(progressBar);
         amcEngine.registerProgressIndicator(progressLog);

OREAnalytics/orea/app/analytic.hpp

@@ -225,7 +225,8 @@ class XvaAnalytic : public virtual Analytic {
     void buildClassicCube(const boost::shared_ptr<Portfolio>& portfolio);
     boost::shared_ptr<Portfolio> classicRun(const boost::shared_ptr<Portfolio>& portfolio);
 
-    boost::shared_ptr<EngineFactory> amcEngineFactory();
+    boost::shared_ptr<EngineFactory> amcEngineFactory(const boost::shared_ptr<QuantExt::CrossAssetModel>& cam,
+                                                      const std::vector<Date>& grid);
     void buildAmcPortfolio();
     void amcRun(bool doClassicRun);
 

OREAnalytics/orea/app/inputparameters.cpp

@@ -120,27 +120,15 @@ void InputParameters::setTodaysMarketParamsFromFile(const std::string& fileName)
 
 void InputParameters::setPortfolio(const std::string& xml) {
     portfolio_ = boost::make_shared<Portfolio>(buildFailedTrades_);
-    boost::shared_ptr<TradeFactory> tradeFactory = nullptr;
-    if (!refDataManager_) {
-        ALOG("reference data manager not set when loading portfolio");
-        tradeFactory = boost::make_shared<TradeFactory>();
-    }
-    tradeFactory = boost::make_shared<TradeFactory>(refDataManager_);
-    portfolio_->loadFromXMLString(xml, tradeFactory);
+    portfolio_->fromXMLString(xml);
 }
 
 void InputParameters::setPortfolioFromFile(const std::string& fileNameString, const std::string& inputPath) {
     vector<string> files = getFileNames(fileNameString, inputPath);
     portfolio_ = boost::make_shared<Portfolio>(buildFailedTrades_);
-    boost::shared_ptr<TradeFactory> tradeFactory = nullptr;
-    if (!refDataManager_) {
-        ALOG("reference data manager not set when loading portfolio");
-        tradeFactory = boost::make_shared<TradeFactory>();
-    }
-    tradeFactory = boost::make_shared<TradeFactory>(refDataManager_);
     for (auto file : files) {
         LOG("Loading portfolio from file: " << file);
-        portfolio_->load(file, tradeFactory);
+        portfolio_->fromFile(file);
     }
 }
 

OREAnalytics/orea/app/oreapp.cpp

@@ -16,8 +16,6 @@
  FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
 */
 
-#include <boost/algorithm/string.hpp>
-#include <boost/timer/timer.hpp>
 
 #ifdef BOOST_MSVC
 // disable warning C4503: '__LINE__Var': decorated name length exceeded, name was truncated
@@ -27,18 +25,21 @@
 #pragma warning(disable : 4503)
 #endif
 
-#include <boost/filesystem.hpp>
-
+#include <orea/app/marketdatainmemoryloader.hpp>
+#include <orea/app/oreapp.hpp>
 #include <orea/orea.hpp>
 #include <ored/ored.hpp>
+#include <ored/report/inmemoryreport.hpp>
 #include <ored/utilities/calendaradjustmentconfig.hpp>
 #include <ored/utilities/currencyconfig.hpp>
+
 #include <ql/cashflows/floatingratecoupon.hpp>
 #include <ql/time/calendars/all.hpp>
 #include <ql/time/daycounters/all.hpp>
-#include <ored/report/inmemoryreport.hpp>
 
-#include <orea/app/oreapp.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/timer/timer.hpp>
 
 #include <iostream>
 
@@ -1355,10 +1356,10 @@ boost::shared_ptr<XvaRunner> OREApp::getXvaRunner() {
     }
 
     boost::shared_ptr<XvaRunner> xva = boost::make_shared<XvaRunner>(
-        asof_, baseCcy, portfolio_, nettingSetManager, engineData, curveConfigs_, marketParameters,
-        simMarketParameters, scenarioGeneratorData, modelData, getExtraLegBuilders(), getExtraEngineBuilders(),
-        referenceData, iborFallbackConfig_, dimQuantile, dimHorizonCalendarDays, analytics, calculationType, dvaName,
-        fvaBorrowingCurve, fvaLendingCurve, fullInitialCollateralisation, storeFlows);
+        asof_, baseCcy, portfolio_, nettingSetManager, engineData, curveConfigs_, marketParameters, simMarketParameters,
+        scenarioGeneratorData, modelData, referenceData, iborFallbackConfig_, dimQuantile, dimHorizonCalendarDays,
+        analytics, calculationType, dvaName, fvaBorrowingCurve, fvaLendingCurve, fullInitialCollateralisation,
+        storeFlows);
 
     return xva;
 }
@@ -1508,21 +1509,14 @@ boost::shared_ptr<EngineFactory> OREApp::buildEngineFactory(const boost::shared_
     configurations[MarketContext::pricing] = params_->get("markets", "pricing");
     LOG("MarketContext::pricing = " << params_->get("markets", "pricing"));
     boost::shared_ptr<EngineFactory> factory =
-        boost::make_shared<EngineFactory>(engineData, market, configurations, getExtraEngineBuilders(),
-                                          getExtraLegBuilders(), referenceData_, iborFallbackConfig_);
+        boost::make_shared<EngineFactory>(engineData, market, configurations, referenceData_, iborFallbackConfig_);
 
     LOG("Engine factory built");
     MEM_LOG;
 
     return factory;
 }
 
-boost::shared_ptr<TradeFactory> OREApp::buildTradeFactory() const {
-    boost::shared_ptr<TradeFactory> tf = boost::make_shared<TradeFactory>(referenceData_);
-    tf->addExtraBuilders(getExtraTradeBuilders(tf));
-    return tf;
-}
-
 boost::shared_ptr<Portfolio> OREApp::buildPortfolio(const boost::shared_ptr<EngineFactory>& factory, bool buildFailedTrades) {
     MEM_LOG;
     LOG("Building portfolio");
@@ -1540,7 +1534,7 @@ boost::shared_ptr<Portfolio> OREApp::loadPortfolio(bool buildFailedTrades) {
         return portfolio;
     vector<string> portfolioFiles = getFileNames(portfoliosString, inputPath_);
     for (auto portfolioFile : portfolioFiles) {
-        portfolio->load(portfolioFile, buildTradeFactory());
+        portfolio->fromFile(portfolioFile);
     }
     return portfolio;
 }
@@ -1736,9 +1730,7 @@ boost::shared_ptr<ReportWriter> OREApp::getReportWriter() const {
 }
 
 boost::shared_ptr<SensitivityRunner> OREApp::getSensitivityRunner() {
-    return boost::make_shared<SensitivityRunner>(params_, buildTradeFactory(), getExtraEngineBuilders(),
-                                                 getExtraLegBuilders(), referenceData_, iborFallbackConfig_,
-                                                 continueOnError_);
+    return boost::make_shared<SensitivityRunner>(params_, referenceData_, iborFallbackConfig_, continueOnError_);
 }
 
 void OREApp::runStressTest() {
@@ -1772,8 +1764,7 @@ void OREApp::runStressTest() {
     string marketConfiguration = params_->get("markets", "pricing");
     boost::shared_ptr<StressTest> stressTest = boost::make_shared<StressTest>(
         portfolio, market_, marketConfiguration, engineData, simMarketData, stressData, *curveConfigs_,
-        *marketParameters_, nullptr, getExtraEngineBuilders(), getExtraLegBuilders(), referenceData_,
-        iborFallbackConfig_, continueOnError_);
+        *marketParameters_, nullptr, referenceData_, iborFallbackConfig_, continueOnError_);
 
     string outputFile = outputPath_ + "/" + params_->get("stress", "scenarioOutputFile");
     Real threshold = parseReal(params_->get("stress", "outputThreshold"));
@@ -2458,8 +2449,7 @@ boost::shared_ptr<EngineFactory> OREApp::buildEngineFactoryFromXMLString(const b
         configurations[MarketContext::fxCalibration] = params_->get("markets", "fxcalibration");
         configurations[MarketContext::pricing] = params_->get("markets", "pricing");
         boost::shared_ptr<EngineFactory> factory =
-            boost::make_shared<EngineFactory>(engineData, market, configurations, getExtraEngineBuilders(),
-                                              getExtraLegBuilders(), referenceData_, iborFallbackConfig_);
+            boost::make_shared<EngineFactory>(engineData, market, configurations, referenceData_, iborFallbackConfig_);
         return factory;
     }
 }