#include <ored/scripting/engines/scriptedinstrumentpricingengine.hpp>

Inheritance diagram for ScriptedInstrumentPricingEngine:

Collaboration diagram for ScriptedInstrumentPricingEngine:

Public Member Functions
	ScriptedInstrumentPricingEngine (const std::string &npv, const std::vector< std::pair< std::string, std::string > > &additionalResults, const QuantLib::ext::shared_ptr< Model > &model, const ASTNodePtr ast, const QuantLib::ext::shared_ptr< Context > &context, const std::string &script="", const bool interactive=false, const bool amcEnabled=false, const std::set< std::string > &amcStickyCloseOutStates={}, const bool generateAdditionalResults=false, const bool includePastCashflows=false)

bool	lastCalculationWasValid () const

Private Member Functions
void	calculate () const override

Real	addMcErrorEstimate (const std::string &label, const ValueType &v) const

Private Attributes
bool	lastCalculationWasValid_ = false

const std::string	npv_

const std::vector< std::pair< std::string, std::string > >	additionalResults_

const QuantLib::ext::shared_ptr< Model >	model_

const ASTNodePtr	ast_

const QuantLib::ext::shared_ptr< Context >	context_

const std::string	script_

const bool	interactive_

const bool	amcEnabled_

const std::set< std::string >	amcStickyCloseOutStates_

const bool	generateAdditionalResults_

const bool	includePastCashflows_

Detailed Description

Definition at line 35 of file scriptedinstrumentpricingengine.hpp.

Constructor & Destructor Documentation

◆ ScriptedInstrumentPricingEngine()

ScriptedInstrumentPricingEngine	(	const std::string &	npv,
		const std::vector< std::pair< std::string, std::string > > &	additionalResults,
		const QuantLib::ext::shared_ptr< Model > &	model,
		const ASTNodePtr	ast,
		const QuantLib::ext::shared_ptr< Context > &	context,
		const std::string &	script = `""`,
		const bool	interactive = `false`,
		const bool	amcEnabled = `false`,
		const std::set< std::string > &	amcStickyCloseOutStates = `{}`,
		const bool	generateAdditionalResults = `false`,
		const bool	includePastCashflows = `false`
	)

Definition at line 37 of file scriptedinstrumentpricingengine.hpp.

                                                                                       {},
                                    const bool generateAdditionalResults = false,
                                    const bool includePastCashflows = false)
        : npv_(npv), additionalResults_(additionalResults), model_(model), ast_(ast), context_(context),
          script_(script), interactive_(interactive), amcEnabled_(amcEnabled),
          amcStickyCloseOutStates_(amcStickyCloseOutStates), generateAdditionalResults_(generateAdditionalResults),
          includePastCashflows_(includePastCashflows) {
        registerWith(model_);
    }

Member Function Documentation

◆ lastCalculationWasValid()

bool lastCalculationWasValid ( ) const

Definition at line 52 of file scriptedinstrumentpricingengine.hpp.

52{ return lastCalculationWasValid_; }

ore::data::ScriptedInstrumentPricingEngine::lastCalculationWasValid_

bool lastCalculationWasValid_

Definition: scriptedinstrumentpricingengine.hpp:59

◆ calculate()

void calculate ( ) const

overrideprivate

Definition at line 67 of file scriptedinstrumentpricingengine.cpp.

                                                      {
 
    lastCalculationWasValid_ = false;
 
    // make sure we release the memory allocated by the model after the pricing
    struct MemoryReleaser {
        ~MemoryReleaser() { model->releaseMemory(); }
        QuantLib::ext::shared_ptr<Model> model;
    };
    MemoryReleaser memoryReleaser{model_};
 
    // set up copy of initial context to run the script engine on
 
    auto workingContext = QuantLib::ext::make_shared<Context>(*context_);
 
    // set TODAY in the context
 
    checkDuplicateName(workingContext, "TODAY");
    Date referenceDate = model_->referenceDate();
    workingContext->scalars["TODAY"] = EventVec{model_->size(), referenceDate};
    workingContext->constants.insert("TODAY");
 
    // clear NPVMem() regression coefficients
 
    model_->resetNPVMem();
 
    // if the model uses a separate training phase for NPV(), run this
 
    if (model_->trainingSamples() != Null<Size>()) {
        auto trainingContext = QuantLib::ext::make_shared<Context>(*workingContext);
        trainingContext->resetSize(model_->trainingSamples());
        struct TrainingPathToggle {
            TrainingPathToggle(QuantLib::ext::shared_ptr<Model> model) : model(model) { model->toggleTrainingPaths(); }
            ~TrainingPathToggle() { model->toggleTrainingPaths(); }
            QuantLib::ext::shared_ptr<Model> model;
        } toggle(model_);
        ScriptEngine trainingEngine(ast_, trainingContext, model_);
        trainingEngine.run(script_, interactive_);
    }
 
    // set up script engine and run it
 
    ScriptEngine engine(ast_, workingContext, model_);
 
    QuantLib::ext::shared_ptr<PayLog> paylog;
    if (generateAdditionalResults_)
        paylog = QuantLib::ext::make_shared<PayLog>();
 
    engine.run(script_, interactive_, paylog, includePastCashflows_);
 
    // extract npv result and set it
 
    auto npv = workingContext->scalars.find(npv_);
    QL_REQUIRE(npv != workingContext->scalars.end(),
               "did not find npv result variable '" << npv_ << "' as scalar in context");
    QL_REQUIRE(npv->second.which() == ValueTypeWhich::Number,
               "result variable '" << npv_ << "' must be of type NUMBER, got " << npv->second.which());
    results_.value = model_->extractT0Result(QuantLib::ext::get<RandomVariable>(npv->second));
    DLOG("got NPV = " << results_.value << " " << model_->baseCcy());
 
    // set additional results, if this feature is enabled
 
    if (generateAdditionalResults_) {
        results_.errorEstimate = addMcErrorEstimate("NPV_MCErrEst", npv->second);
        for (auto const& r : additionalResults_) {
            auto s = workingContext->scalars.find(r.second);
            bool resultSet = false;
            if (s != workingContext->scalars.end()) {
                boost::any t = valueToAny(model_, s->second);
                results_.additionalResults[r.first] = t;
                addMcErrorEstimate(r.first + "_MCErrEst", s->second);
                DLOG("got additional result '" << r.first << "' referencing script variable '" << r.second << "'");
                resultSet = true;
            }
            auto v = workingContext->arrays.find(r.second);
            if (v != workingContext->arrays.end()) {
                QL_REQUIRE(!resultSet, "result variable '"
                                           << r.first << "' referencing script variable '" << r.second
                                           << "' appears both as a scalar and an array, this is unexpected");
                QL_REQUIRE(!v->second.empty(), "result variable '" << v->first << "' is an empty array.");
                std::vector<double> tmpdouble;
                std::vector<std::string> tmpstring;
                std::vector<QuantLib::Date> tmpdate;
                for (auto const& d : v->second) {
                    boost::any t = valueToAny(model_, d);
                    if (t.type() == typeid(double))
                        tmpdouble.push_back(boost::any_cast<double>(t));
                    else if (t.type() == typeid(std::string))
                        tmpstring.push_back(boost::any_cast<std::string>(t));
                    else if (t.type() == typeid(QuantLib::Date))
                        tmpdate.push_back(boost::any_cast<QuantLib::Date>(t));
                    else {
                        QL_FAIL("unexpected result type '" << t.type().name() << "' for result variable '" << r.first
                                                           << "' referencing script variable '" << r.second << "'");
                    }
                }
                QL_REQUIRE((int)!tmpdouble.empty() + (int)!tmpstring.empty() + (int)!tmpdate.empty() == 1,
                           "expected exactly one result type in result array '" << v->first << "'");
                DLOG("got additional result '" << r.first << "' referencing script variable '" << r.second
                                               << "' vector of size "
                                               << tmpdouble.size() + tmpstring.size() + tmpdate.size());
                if (!tmpdouble.empty())
                    results_.additionalResults[r.first] = tmpdouble;
                else if (!tmpstring.empty())
                    results_.additionalResults[r.first] = tmpstring;
                else if (!tmpdate.empty())
                    results_.additionalResults[r.first] = tmpdate;
                else {
                    QL_FAIL("got empty result vector for result variable '"
                            << r.first << "' referencing script variable '" << r.second << "', this is unexpected");
                }
                std::vector<double> errEst;
                for (auto const& d : v->second) {
                    errEst.push_back(addMcErrorEstimate(std::string(), d));
                }
                if (!errEst.empty() && errEst.front() != Null<Real>())
                    results_.additionalResults[r.first + "_MCErrEst"] = errEst;
                resultSet = true;
            }
            QL_REQUIRE(resultSet, "could not set additional result '" << r.first << "' referencing script variable '"
                                                                      << r.second << "'");
        }
 
        // set contents from paylog as additional results
 
        paylog->consolidateAndSort();
        std::vector<CashFlowResults> cashFlowResults(paylog->size());
        std::map<Size, Size> cashflowNumber;
        for (Size i = 0; i < paylog->size(); ++i) {
            // cashflow is written as expectation of deflated base ccy amount at T0, converted to flow ccy
            // with the T0 FX Spot and compounded back to the pay date on T0 curves
            Real fx = 1.0;
            Real discount = 1.0;
            if (paylog->dates().at(i) > model_->referenceDate()) {
                fx = model_->fxSpotT0(paylog->currencies().at(i), model_->baseCcy());
                discount = model_->discount(referenceDate, paylog->dates().at(i), paylog->currencies().at(i)).at(0);
            }
            cashFlowResults[i].amount = model_->extractT0Result(paylog->amounts().at(i)) / fx / discount;
            cashFlowResults[i].payDate = paylog->dates().at(i);
            cashFlowResults[i].currency = paylog->currencies().at(i);
            cashFlowResults[i].legNumber = paylog->legNos().at(i);
            cashFlowResults[i].type = paylog->cashflowTypes().at(i);
            DLOG("got cashflow " << QuantLib::io::iso_date(cashFlowResults[i].payDate) << " "
                                 << cashFlowResults[i].currency << cashFlowResults[i].amount << " "
                                 << cashFlowResults[i].currency << "-" << model_->baseCcy() << " " << fx << " discount("
                                 << cashFlowResults[i].currency << ") " << discount);
            if (paylog->dates().at(i) > model_->referenceDate()) {
                addMcErrorEstimate("cashflow_" + std::to_string(paylog->legNos().at(i)) + "_" +
                                       std::to_string(++cashflowNumber[paylog->legNos().at(i)]) + "_MCErrEst",
                                   paylog->amounts().at(i) /
                                       RandomVariable(paylog->amounts().at(i).size(), (fx * discount)));
            }
        }
        results_.additionalResults["cashFlowResults"] = cashFlowResults;
 
        // set additional results from the model
 
        results_.additionalResults.insert(model_->additionalResults().begin(), model_->additionalResults().end());
 
    } // if generate additional results
 
    // if the engine is amc enabled, add an amc calculator to the additional results
 
    if (amcEnabled_) {
        DLOG("add amc calculator to results");
        results_.additionalResults["amcCalculator"] =
            QuantLib::ext::static_pointer_cast<AmcCalculator>(QuantLib::ext::make_shared<ScriptedInstrumentAmcCalculator>(
                npv_, model_, ast_, context_, script_, interactive_, amcStickyCloseOutStates_));
    }
 
    lastCalculationWasValid_ = true;
}

Here is the call graph for this function:

◆ addMcErrorEstimate()

Real addMcErrorEstimate	(	const std::string &	label,
		const ValueType &	v
	)		const

private

Definition at line 55 of file scriptedinstrumentpricingengine.cpp.

                                                                                                         {
    if (model_->type() != Model::Type::MC)
        return Null<Real>();
    if (v.which() != ValueTypeWhich::Number)
        return Null<Real>();
    Real var = variance(QuantLib::ext::get<RandomVariable>(v)).at(0);
    Real errEst = std::sqrt(var / static_cast<double>(model_->size()));
    if(!label.empty())
        results_.additionalResults[label] = errEst;
    return errEst;
}