Orchestrates the processes covered by ORE, data loading, analytics and reporting. More...

#include <orea/app/oreapp.hpp>

Collaboration diagram for OREApp:

Public Member Functions
	OREApp (QuantLib::ext::shared_ptr< Parameters > params, bool console=false, const boost::filesystem::path &logRootPath=boost::filesystem::path())
	Constructor that uses ORE parameters and input data from files. More...

	OREApp (const QuantLib::ext::shared_ptr< InputParameters > &inputs, const std::string &logFile, Size logLevel=31, bool console=false, const boost::filesystem::path &logRootPath=boost::filesystem::path())
	Constructor that assumes we have already assembled input parameters via API. More...

virtual	~OREApp ()
	Destructor. More...

virtual void	run ()
	Runs analytics and generates reports after using the first OREApp c'tor. More...

void	run (const std::vector< std::string > &marketData, const std::vector< std::string > &fixingData)
	Runs analytics and generates reports after using the second OREApp c'tor. More...

QuantLib::ext::shared_ptr< InputParameters >	getInputs ()

std::set< std::string >	getAnalyticTypes ()

std::set< std::string >	getSupportedAnalyticTypes ()

const QuantLib::ext::shared_ptr< Analytic > &	getAnalytic (std::string type)

std::set< std::string >	getReportNames ()

QuantLib::ext::shared_ptr< PlainInMemoryReport >	getReport (std::string reportName)

std::set< std::string >	getCubeNames ()

QuantLib::ext::shared_ptr< NPVCube >	getCube (std::string cubeName)

std::set< std::string >	getMarketCubeNames ()

QuantLib::ext::shared_ptr< AggregationScenarioData >	getMarketCube (std::string cubeName)

std::vector< std::string >	getErrors ()

Real	getRunTime ()
	time for executing run(...) in seconds More...

std::string	version ()

Protected Member Functions
virtual void	analytics ()

void	buildInputParameters (QuantLib::ext::shared_ptr< InputParameters > inputs, const QuantLib::ext::shared_ptr< Parameters > &params)
	Populate InputParameters object from classic ORE key-value pairs in Parameters. More...

QuantLib::ext::shared_ptr< CSVLoader >	buildCsvLoader (const QuantLib::ext::shared_ptr< Parameters > &params)

void	setupLog (const std::string &path, const std::string &file, QuantLib::Size mask, const boost::filesystem::path &logRootPath, const std::string &progressLogFile="", QuantLib::Size progressLogRotationSize=100 1024 1024, bool progressLogToConsole=false, const std::string &structuredLogFile="", QuantLib::Size structuredLogRotationSize=100 1024 1024)
	set up logging More...

void	closeLog ()
	remove logs More...

void	initFromParams ()

void	initFromInputs ()

Protected Attributes
QuantLib::ext::shared_ptr< Parameters >	params_
	ORE Input parameters. More...

QuantLib::ext::shared_ptr< InputParameters >	inputs_

QuantLib::ext::shared_ptr< OutputParameters >	outputs_

QuantLib::ext::shared_ptr< AnalyticsManager >	analyticsManager_

QuantLib::ext::shared_ptr< StructuredLogger >	structuredLogger_

boost::timer::cpu_timer	runTimer_

string	logFile_
	Logging. More...

Size	logMask_

bool	console_

string	outputPath_

boost::filesystem::path	logRootPath_

string	progressLogFile_ = ""

QuantLib::Size	progressLogRotationSize_ = 100 * 1024 * 1024

bool	progressLogToConsole_ = false

string	structuredLogFile_ = ""

QuantLib::Size	structuredLogRotationSize_ = 100 * 1024 * 1024

std::vector< std::string >	errorMessages_

Detailed Description

Orchestrates the processes covered by ORE, data loading, analytics and reporting.

Definition at line 40 of file oreapp.hpp.

Constructor & Destructor Documentation

◆ OREApp() [1/2]

OREApp	(	QuantLib::ext::shared_ptr< Parameters >	params,
		bool	console = `false`,
		const boost::filesystem::path &	logRootPath = `boost::filesystem::path()`
	)

Constructor that uses ORE parameters and input data from files.

Definition at line 43 of file oreapp.hpp.

45 : params_(params), inputs_(nullptr), console_(console), logRootPath_(logRootPath) {}

ore::analytics::OREApp::params_

QuantLib::ext::shared_ptr< Parameters > params_

ORE Input parameters.

Definition: oreapp.hpp:104

ore::analytics::OREApp::logRootPath_

boost::filesystem::path logRootPath_

Definition: oreapp.hpp:117

ore::analytics::OREApp::console_

bool console_

Definition: oreapp.hpp:115

ore::analytics::OREApp::inputs_

QuantLib::ext::shared_ptr< InputParameters > inputs_

Definition: oreapp.hpp:105

◆ OREApp() [2/2]

OREApp	(	const QuantLib::ext::shared_ptr< InputParameters > &	inputs,
		const std::string &	logFile,
		Size	logLevel = `31`,
		bool	console = `false`,
		const boost::filesystem::path &	logRootPath = `boost::filesystem::path()`
	)

Constructor that assumes we have already assembled input parameters via API.

Definition at line 48 of file oreapp.hpp.

50 : params_(nullptr), inputs_(inputs), logFile_(logFile), logMask_(logLevel), console_(console),

51 logRootPath_(logRootPath) {}

ore::analytics::OREApp::logMask_

Size logMask_

Definition: oreapp.hpp:114

ore::analytics::OREApp::logFile_

string logFile_

Logging.

Definition: oreapp.hpp:113

◆ ~OREApp()

~OREApp ( )

virtual

Destructor.

Definition at line 393 of file oreapp.cpp.

                {
    // Close logs
    closeLog();
}

Here is the call graph for this function:

Member Function Documentation

◆ run() [1/2]

void run ( )

virtual

Runs analytics and generates reports after using the first OREApp c'tor.

Definition at line 398 of file oreapp.cpp.

                 {
 
    // Only one thread at a time should call run
    static std::mutex _s_mutex;
    std::lock_guard<std::mutex> lock(_s_mutex);
 
    // Clean start, but leave Singletons intact after run is completed
    {
      CleanUpThreadLocalSingletons cleanupThreadLocalSingletons;
      CleanUpThreadGlobalSingletons cleanupThreadGloablSingletons;
      CleanUpLogSingleton cleanupLogSingleton(true, true);
    }
 
    // Use inputs when available, otherwise try params
    if (inputs_ != nullptr)
        initFromInputs();
    else if (params_ != nullptr)
        initFromParams();
    else {
        ALOG("both inputs are empty");
    return;
    }
 
    runTimer_.start();
    
    try {
        structuredLogger_->clear();
        analytics();
    } catch (std::exception& e) {
        StructuredAnalyticsWarningMessage("OREApp::run()", "Error", e.what()).log();
        CONSOLE("Error: " << e.what());
        return;
    }
 
    runTimer_.stop();
 
    // cache the error messages because we reset the loggers 
    errorMessages_ = structuredLogger_->messages();
 
    CONSOLE("run time: " << runTimer_.format(default_places, "%w") << " sec");
    CONSOLE("ORE done.");
    LOG("ORE done.");
}

Here is the call graph for this function:

◆ run() [2/2]

void run	(	const std::vector< std::string > &	marketData,
		const std::vector< std::string > &	fixingData
	)

Runs analytics and generates reports after using the second OREApp c'tor.

Definition at line 442 of file oreapp.cpp.

                                                         {
 
    // Only one thread at a time should call run
    static std::mutex _s_mutex;
    std::lock_guard<std::mutex> lock(_s_mutex);
 
    // Clean start, but leave Singletons intact after run is completed
    {
      CleanUpThreadLocalSingletons cleanupThreadLocalSingletons;
      CleanUpThreadGlobalSingletons cleanupThreadGloablSingletons;
      CleanUpLogSingleton cleanupLogSingleton(true, true);
    }
 
    // Use inputs when available, otherwise try params
    if (inputs_ != nullptr)
        initFromInputs();
    else if (params_ != nullptr)
        initFromParams();
    else {
        ALOG("both inputs are empty");
    return;
    }
 
    runTimer_.start();
 
    try {
        LOG("ORE analytics starting");
        structuredLogger_->clear();
        MEM_LOG_USING_LEVEL(ORE_WARNING)
 
        QL_REQUIRE(inputs_, "ORE input parameters not set");
        
        // Set global evaluation date, though already set in the OREAppInputParameters c'tor
        Settings::instance().evaluationDate() = inputs_->asof();
 
        // FIXME
        QL_REQUIRE(inputs_->pricingEngine(), "pricingEngine not set");
        GlobalPseudoCurrencyMarketParameters::instance().set(inputs_->pricingEngine()->globalParameters());
 
        // Initialize the global conventions 
        QL_REQUIRE(inputs_->conventions(), "conventions not set");
        InstrumentConventions::instance().setConventions(inputs_->conventions());
 
        // Create a market data loader that takes input from the provided vectors
        auto loader = QuantLib::ext::make_shared<MarketDataInMemoryLoader>(inputs_, marketData, fixingData);
 
        // Create the analytics manager
        analyticsManager_ = QuantLib::ext::make_shared<AnalyticsManager>(inputs_, loader);
        LOG("Available analytics: " << to_string(analyticsManager_->validAnalytics()));
        CONSOLEW("Requested analytics:");
        CONSOLE(to_string(inputs_->analytics()));
        LOG("Requested analytics: " << to_string(inputs_->analytics()));
 
        QuantLib::ext::shared_ptr<MarketCalibrationReportBase> mcr;
        if (inputs_->outputTodaysMarketCalibration()) {
            auto marketCalibrationReport = QuantLib::ext::make_shared<ore::data::InMemoryReport>();
            mcr = QuantLib::ext::make_shared<MarketCalibrationReport>(string(), marketCalibrationReport);
        }
 
        // Run the requested analytics
        analyticsManager_->runAnalytics(mcr);
 
        MEM_LOG_USING_LEVEL(ORE_WARNING)
        // Leave any report writing to the calling aplication
    }
    catch (std::exception& e) {
        ostringstream oss;
        oss << "Error in ORE analytics: " << e.what();
        StructuredAnalyticsWarningMessage("OREApp::run()", oss.str(), e.what()).log();
        MEM_LOG_USING_LEVEL(ORE_WARNING)
        CONSOLE(oss.str());
        QL_FAIL(oss.str());
        return;
    }
 
    runTimer_.stop();
    
    LOG("ORE analytics done");
}

Here is the call graph for this function:

◆ getInputs()

QuantLib::ext::shared_ptr< InputParameters > getInputs ( )

Definition at line 63 of file oreapp.hpp.

63{ return inputs_; }

◆ getAnalyticTypes()

std::set< std::string > getAnalyticTypes ( )

Definition at line 64 of file oreapp.cpp.

                                           {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    return analyticsManager_->requestedAnalytics();
}

◆ getSupportedAnalyticTypes()

std::set< std::string > getSupportedAnalyticTypes ( )

Definition at line 69 of file oreapp.cpp.

                                                    {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    return analyticsManager_->validAnalytics();
}

◆ getAnalytic()

const QuantLib::ext::shared_ptr< Analytic > & getAnalytic ( std::string type )

Definition at line 74 of file oreapp.cpp.

                                                                         {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    return analyticsManager_->getAnalytic(type);
}

◆ getReportNames()

std::set< std::string > getReportNames ( )

Definition at line 79 of file oreapp.cpp.

                                         {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    std::set<std::string> names;
    for (const auto& rep : analyticsManager_->reports()) {
        for (auto b : rep.second) {
            string reportName = b.first;
            if (names.find(reportName) == names.end())
                names.insert(reportName);
            else {
                ALOG("report name " << reportName
                     << " occurs more than once, will retrieve the first report with that only");
            }
        }
    }
    return names;
}

◆ getReport()

QuantLib::ext::shared_ptr< PlainInMemoryReport > getReport ( std::string reportName )

Definition at line 96 of file oreapp.cpp.

                                                                                 {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    for (const auto& rep : analyticsManager_->reports()) {
        for (auto b : rep.second) {
            if (reportName == b.first)
                return QuantLib::ext::make_shared<PlainInMemoryReport>(b.second);
        }
    }
    QL_FAIL("report " << reportName << " not found in results");
}

◆ getCubeNames()

std::set< std::string > getCubeNames ( )

Definition at line 107 of file oreapp.cpp.

                                       {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    std::set<std::string> names;
    for (const auto& c : analyticsManager_->npvCubes()) {
        for (auto b : c.second) {
            string cubeName = b.first;
            if (names.find(cubeName) == names.end())
                names.insert(cubeName);
            else {
                ALOG("cube name " << cubeName
                     << " occurs more than once, will retrieve the first cube with that name only");
            }
        }
    }
    return names;
}

◆ getCube()

QuantLib::ext::shared_ptr< NPVCube > getCube ( std::string cubeName )

Definition at line 124 of file oreapp.cpp.

                                                                 {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    for (const auto& c : analyticsManager_->npvCubes()) {
        for (auto b : c.second) {
            if (cubeName == b.first)
                return b.second;
        }
    }
    QL_FAIL("npv cube " << cubeName << " not found in results");
}

◆ getMarketCubeNames()

std::set< std::string > getMarketCubeNames ( )

Definition at line 135 of file oreapp.cpp.

                                             {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    std::set<std::string> names;
    for (const auto& c : analyticsManager_->mktCubes()) {
        for (auto b : c.second) {
            string cubeName = b.first;
            if (names.find(cubeName) == names.end())
                names.insert(cubeName);
            else {
                ALOG("market cube name " << cubeName
                     << " occurs more than once, will retrieve the first cube with that name only");
            }
        }
    }
    return names;
}

◆ getMarketCube()

QuantLib::ext::shared_ptr< AggregationScenarioData > getMarketCube ( std::string cubeName )

Definition at line 152 of file oreapp.cpp.

                                                                                       {
    QL_REQUIRE(analyticsManager_, "analyticsManager_ not set yet, call analytics first");
    for (const auto& c : analyticsManager_->mktCubes()) {
        for (auto b : c.second) {
            if (cubeName == b.first)
                return b.second;
        }
    }
    QL_FAIL("market cube " << cubeName << " not found in results");
}

◆ getErrors()

std::vector< std::string > getErrors ( )

Definition at line 163 of file oreapp.cpp.

                                       {
    return errorMessages_;
}

◆ getRunTime()

Real getRunTime ( )

time for executing run(...) in seconds

Definition at line 167 of file oreapp.cpp.

                        {
    boost::chrono::duration<double> seconds = boost::chrono::nanoseconds(runTimer_.elapsed().wall);
    return seconds.count();
}

◆ version()

std::string version ( )

Definition at line 564 of file oreapp.cpp.

564{ return std::string(OPEN_SOURCE_RISK_VERSION); }

◆ analytics()

void analytics ( )

protectedvirtual

Definition at line 218 of file oreapp.cpp.

                       {
 
    try {
        LOG("ORE analytics starting");
        MEM_LOG_USING_LEVEL(ORE_WARNING)
 
        QL_REQUIRE(params_, "ORE input parameters not set");
                
        Settings::instance().evaluationDate() = inputs_->asof();
 
        GlobalPseudoCurrencyMarketParameters::instance().set(inputs_->pricingEngine()->globalParameters());
 
        // Initialize the global conventions 
        InstrumentConventions::instance().setConventions(inputs_->conventions());
 
        // Create a market data loader that reads market data, fixings, dividends from csv files
        auto csvLoader = buildCsvLoader(params_);
        auto loader = QuantLib::ext::make_shared<MarketDataCsvLoader>(inputs_, csvLoader);
 
        // Create the analytics manager
        analyticsManager_ = QuantLib::ext::make_shared<AnalyticsManager>(inputs_, loader);
        LOG("Available analytics: " << to_string(analyticsManager_->validAnalytics()));
        CONSOLEW("Requested analytics");
        CONSOLE(to_string(inputs_->analytics()));
        LOG("Requested analytics: " << to_string(inputs_->analytics()));
 
        QuantLib::ext::shared_ptr<MarketCalibrationReportBase> mcr;
        if (inputs_->outputTodaysMarketCalibration()) {
            auto marketCalibrationReport = QuantLib::ext::make_shared<ore::data::InMemoryReport>();
            mcr = QuantLib::ext::make_shared<MarketCalibrationReport>(string(), marketCalibrationReport);
        }
 
        // Run the requested analytics
        analyticsManager_->runAnalytics(mcr);
 
        // Write reports to files in the results path
        Analytic::analytic_reports reports = analyticsManager_->reports();
        analyticsManager_->toFile(reports,
                                  inputs_->resultsPath().string(), outputs_->fileNameMap(),
                                  inputs_->csvSeparator(), inputs_->csvCommentCharacter(),
                                  inputs_->csvQuoteChar(), inputs_->reportNaString());
 
        // Write npv cube(s)
        for (auto a : analyticsManager_->npvCubes()) {
            for (auto b : a.second) {
                LOG("write npv cube " << b.first);
                string reportName = b.first;
                std::string fileName = inputs_->resultsPath().string() + "/" + outputs_->outputFileName(reportName, "csv.gz");
                LOG("write npv cube " << reportName << " to file " << fileName);
                NPVCubeWithMetaData r;
                r.cube = b.second;
                if (b.first == "cube") {
                    // store meta data together with npv cube
                    r.scenarioGeneratorData = inputs_->scenarioGeneratorData();
                    r.storeFlows = inputs_->storeFlows();
                    r.storeCreditStateNPVs = inputs_->storeCreditStateNPVs();
                }
                saveCube(fileName, r);
            }
        }
        
        // Write market cube(s)
        for (auto a : analyticsManager_->mktCubes()) {
            for (auto b : a.second) {
                string reportName = b.first;
                std::string fileName = inputs_->resultsPath().string() + "/" + outputs_->outputFileName(reportName, "csv.gz");
                LOG("write market cube " << reportName << " to file " << fileName);
                saveAggregationScenarioData(fileName, *b.second);
            }
        }
 
        for (auto a: analyticsManager_->stressTests()){
            for(auto b: a.second){
                string reportName = b.first;
                std::string fileName =
                    inputs_->resultsPath().string() + "/" + outputs_->outputFileName(reportName, "xml");
                LOG("write converted stress test scenario definition " << reportName << " to file " << fileName);
                b.second->toFile(fileName);
            }
        }
 
    }
    catch (std::exception& e) {
        ostringstream oss;
        oss << "Error in ORE analytics: " << e.what();
        ALOG(oss.str());
        MEM_LOG_USING_LEVEL(ORE_WARNING)
        CONSOLE(oss.str());
        QL_FAIL(oss.str());
    }
 
    MEM_LOG_USING_LEVEL(ORE_WARNING)
    LOG("ORE analytics done");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildInputParameters()

void buildInputParameters	(	QuantLib::ext::shared_ptr< InputParameters >	inputs,
		const QuantLib::ext::shared_ptr< Parameters > &	params
	)

protected

Populate InputParameters object from classic ORE key-value pairs in Parameters.

◆ buildCsvLoader()

QuantLib::ext::shared_ptr< CSVLoader > buildCsvLoader ( const QuantLib::ext::shared_ptr< Parameters > & params )

protected

Definition at line 172 of file oreapp.cpp.

                                                                                                       {
    bool implyTodaysFixings = false;
    vector<string> marketFiles = {};
    vector<string> fixingFiles = {};
    vector<string> dividendFiles = {};
 
    filesystem::path inputPath = params_->get("setup", "inputPath");
 
    std::string tmp = params_->get("setup", "implyTodaysFixings", false);
    if (tmp != "")
        implyTodaysFixings = ore::data::parseBool(tmp);
 
    tmp = params->get("setup", "marketDataFile", false);
    if (tmp != "")
        marketFiles = getFileNames(tmp, inputPath);
    else {
        ALOG("market data file not found");
    }
 
    tmp = params->get("setup", "fixingDataFile", false);
    if (tmp != "")
        fixingFiles = getFileNames(tmp, inputPath);
    else {
        ALOG("fixing data file not found");
    }
    
    tmp = params->get("setup", "dividendDataFile", false);
    if (tmp != "")
        dividendFiles = getFileNames(tmp, inputPath);
    else {
        WLOG("dividend data file not found");
    }
 
    tmp = params->get("setup", "fixingCutoff", false);
    Date cutoff = Date();
    if (tmp != "")
        cutoff = parseDate(tmp);
    else {
        WLOG("fixing cutoff date not set");
    }
    
    auto loader = boost::make_shared<CSVLoader>(marketFiles, fixingFiles, dividendFiles, implyTodaysFixings, cutoff);
 
    return loader;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setupLog()

void setupLog	(	const std::string &	path,
		const std::string &	file,
		QuantLib::Size	mask,
		const boost::filesystem::path &	logRootPath,
		const std::string &	progressLogFile = `""`,
		QuantLib::Size	progressLogRotationSize = `100 * 1024 * 1024`,
		bool	progressLogToConsole = `false`,
		const std::string &	structuredLogFile = `""`,
		QuantLib::Size	structuredLogRotationSize = `100 * 1024 * 1024`
	)

protected

set up logging

Definition at line 523 of file oreapp.cpp.

                                                      {
    closeLog();
    
    boost::filesystem::path p{path};
    if (!boost::filesystem::exists(p)) {
        boost::filesystem::create_directories(p);
    }
    QL_REQUIRE(boost::filesystem::is_directory(p), "output path '" << path << "' is not a directory.");
 
    Log::instance().registerLogger(QuantLib::ext::make_shared<FileLogger>(file));
    boost::filesystem::path oreRootPath =
        logRootPath.empty() ? boost::filesystem::path(__FILE__).parent_path().parent_path().parent_path().parent_path()
                            : logRootPath;
    Log::instance().setRootPath(oreRootPath);
    Log::instance().setMask(mask);
    Log::instance().switchOn();
 
    // Progress logger
    auto progressLogger = QuantLib::ext::make_shared<ProgressLogger>();
    string progressLogFilePath = progressLogFile.empty() ? path + "/log_progress.json" : progressLogFile;
    progressLogger->setFileLog(progressLogFilePath, path, progressLogRotationSize);
    progressLogger->setCoutLog(progressLogToConsole);
    Log::instance().registerIndependentLogger(progressLogger);
 
    // Structured message logger
    structuredLogger_ = QuantLib::ext::make_shared<StructuredLogger>();
    string structuredLogFilePath = structuredLogFile.empty() ? path + "/log_structured.json" : structuredLogFile;
    structuredLogger_->setFileLog(structuredLogFilePath, path, structuredLogRotationSize);
    Log::instance().registerIndependentLogger(structuredLogger_);
 
    // Event message logger
    auto eventLogger = QuantLib::ext::make_shared<EventLogger>();
    eventLogger->setFileLog(path + "/log_event_");
    ore::data::Log::instance().registerIndependentLogger(eventLogger);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeLog()

void closeLog ( )

protected

remove logs

Definition at line 562 of file oreapp.cpp.

562{ Log::instance().removeAllLoggers(); }

Here is the caller graph for this function:

◆ initFromParams()

void initFromParams ( )

protected

Definition at line 314 of file oreapp.cpp.

                            {
    if (console_) {
        ConsoleLog::instance().switchOn();
    }
 
    outputPath_ = params_->get("setup", "outputPath");
    logFile_ = outputPath_ + "/" + params_->get("setup", "logFile");
    logMask_ = 15;
    // Get log mask if available
    if (params_->has("setup", "logMask")) {
        logMask_ = static_cast<Size>(parseInteger(params_->get("setup", "logMask")));
    }
 
    progressLogRotationSize_ = 0;
    progressLogToConsole_ = false;
    structuredLogRotationSize_ = 0;
    
    if (params_->hasGroup("logging")) {
        string tmp = params_->get("logging", "logFile", false);
        if (!tmp.empty()) {
            logFile_ = outputPath_ + '/' + tmp;
        }
        tmp = params_->get("logging", "logMask", false);
        if (!tmp.empty()) {
            logMask_ = static_cast<Size>(parseInteger(tmp));
        }
        tmp = params_->get("logging", "progressLogFile", false);
        if (!tmp.empty()) {
            progressLogFile_ = outputPath_ + '/' + tmp;
        }
        tmp = params_->get("logging", "progressLogRotationSize", false);
        if (!tmp.empty()) {
            progressLogRotationSize_ = static_cast<Size>(parseInteger(tmp));
        }
        tmp = params_->get("logging", "progressLogToConsole", false);
        if (!tmp.empty()) {
            progressLogToConsole_ = ore::data::parseBool(tmp);
        }
        tmp = params_->get("logging", "structuredLogFile", false);
        if (!tmp.empty()) {
            structuredLogFile_ = outputPath_ + '/' + tmp;
        }
        tmp = params_->get("logging", "structuredLogRotationSize", false);
        if (!tmp.empty()) {
            structuredLogRotationSize_ = static_cast<Size>(parseInteger(tmp));
        }
    }
    
    setupLog(outputPath_, logFile_, logMask_, logRootPath_, progressLogFile_, progressLogRotationSize_, progressLogToConsole_,
             structuredLogFile_, structuredLogRotationSize_);
 
    // Log the input parameters
    params_->log();
 
    // Read all inputs from params and files referenced in params
    CONSOLEW("Loading inputs");
    inputs_ = QuantLib::ext::make_shared<OREAppInputParameters>(params_);
    inputs_->loadParameters();
    outputs_ = QuantLib::ext::make_shared<OutputParameters>(params_);
    CONSOLE("OK");
 
    Settings::instance().evaluationDate() = inputs_->asof();
    LOG("initFromParameters done, requested analytics:" << to_string(inputs_->analytics()));
} 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initFromInputs()

void initFromInputs ( )

protected

Definition at line 379 of file oreapp.cpp.

                            {
    // Initialise Singletons
    Settings::instance().evaluationDate() = inputs_->asof();
    InstrumentConventions::instance().setConventions(inputs_->conventions());
    if (console_) {
        ConsoleLog::instance().switchOn();
    }
 
    outputPath_ = inputs_->resultsPath().string();
    setupLog(outputPath_, logFile_, logMask_, logRootPath_, progressLogFile_, progressLogRotationSize_, progressLogToConsole_,
             structuredLogFile_, structuredLogRotationSize_);
    LOG("initFromInputs done, requested analytics:" << to_string(inputs_->analytics()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ params_

QuantLib::ext::shared_ptr<Parameters> params_

protected

ORE Input parameters.

Definition at line 104 of file oreapp.hpp.

◆ inputs_

QuantLib::ext::shared_ptr<InputParameters> inputs_

protected

Definition at line 105 of file oreapp.hpp.

◆ outputs_

QuantLib::ext::shared_ptr<OutputParameters> outputs_

protected

Definition at line 106 of file oreapp.hpp.

◆ analyticsManager_

QuantLib::ext::shared_ptr<AnalyticsManager> analyticsManager_

protected

Definition at line 108 of file oreapp.hpp.

◆ structuredLogger_

QuantLib::ext::shared_ptr<StructuredLogger> structuredLogger_

protected

Definition at line 109 of file oreapp.hpp.

◆ runTimer_

boost::timer::cpu_timer runTimer_

protected

Definition at line 110 of file oreapp.hpp.

◆ logFile_

string logFile_

protected

Logging.

Definition at line 113 of file oreapp.hpp.

◆ logMask_

Size logMask_

protected

Definition at line 114 of file oreapp.hpp.

◆ console_

bool console_

protected

Definition at line 115 of file oreapp.hpp.

◆ outputPath_

string outputPath_

protected

Definition at line 116 of file oreapp.hpp.

◆ logRootPath_

boost::filesystem::path logRootPath_

protected

Definition at line 117 of file oreapp.hpp.

◆ progressLogFile_

string progressLogFile_ = ""

protected

Definition at line 118 of file oreapp.hpp.

◆ progressLogRotationSize_

QuantLib::Size progressLogRotationSize_ = 100 * 1024 * 1024

protected

Definition at line 119 of file oreapp.hpp.

◆ progressLogToConsole_

bool progressLogToConsole_ = false

protected

Definition at line 120 of file oreapp.hpp.

◆ structuredLogFile_

string structuredLogFile_ = ""

protected

Definition at line 121 of file oreapp.hpp.

◆ structuredLogRotationSize_

QuantLib::Size structuredLogRotationSize_ = 100 * 1024 * 1024

protected

Definition at line 122 of file oreapp.hpp.

◆ errorMessages_

std::vector<std::string> errorMessages_

protected

Definition at line 125 of file oreapp.hpp.

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OREApp() [1/2]

◆ OREApp() [2/2]

◆ ~OREApp()

Member Function Documentation

◆ run() [1/2]

◆ run() [2/2]

◆ getInputs()

◆ getAnalyticTypes()

◆ getSupportedAnalyticTypes()

◆ getAnalytic()

◆ getReportNames()

◆ getReport()

◆ getCubeNames()

◆ getCube()

◆ getMarketCubeNames()

◆ getMarketCube()

◆ getErrors()

◆ getRunTime()

◆ version()

◆ analytics()

◆ buildInputParameters()

◆ buildCsvLoader()

◆ setupLog()

◆ closeLog()

◆ initFromParams()

◆ initFromInputs()

Member Data Documentation

◆ params_

◆ inputs_

◆ outputs_

◆ analyticsManager_

◆ structuredLogger_

◆ runTimer_

◆ logFile_

◆ logMask_

◆ console_

◆ outputPath_

◆ logRootPath_

◆ progressLogFile_

◆ progressLogRotationSize_

◆ progressLogToConsole_

◆ structuredLogFile_

◆ structuredLogRotationSize_

◆ errorMessages_