Valuation Engine. More...

#include <orea/engine/valuationengine.hpp>

Inheritance diagram for ValuationEngine:

Collaboration diagram for ValuationEngine:

Public Member Functions
	ValuationEngine (const QuantLib::Date &today, const QuantLib::ext::shared_ptr< ore::data::DateGrid > &dg, const QuantLib::ext::shared_ptr< analytics::SimMarket > &simMarket, const set< std::pair< std::string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > > &modelBuilders=set< std::pair< std::string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > >())
	Constructor. More...

void	buildCube (const QuantLib::ext::shared_ptr< data::Portfolio > &portfolio, QuantLib::ext::shared_ptr< analytics::NPVCube > outputCube, std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > > calculators, bool mporStickyDate=true, QuantLib::ext::shared_ptr< analytics::NPVCube > outputCubeNettingSet=nullptr, QuantLib::ext::shared_ptr< analytics::NPVCube > outputCptyCube=nullptr, std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > > cptyCalculators={}, bool dryRun=false)
	Build NPV cube. 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 Member Functions
void	recalibrateModels ()

std::pair< double, double >	populateCube (const QuantLib::Date &d, size_t cubeDateIndex, size_t sample, bool isValueDate, bool isStickyDate, bool scenarioUpdated, const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &trades, std::vector< bool > &tradeHasError, const std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > > &calculators, QuantLib::ext::shared_ptr< analytics::NPVCube > &outputCube, QuantLib::ext::shared_ptr< analytics::NPVCube > &outputCubeNettingSet, const std::map< std::string, size_t > &counterparties, const std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > > &cptyCalculators, QuantLib::ext::shared_ptr< analytics::NPVCube > &outputCptyCube)

void	runCalculators (bool isCloseOutDate, const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &trades, std::vector< bool > &tradeHasError, const std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > > &calculators, QuantLib::ext::shared_ptr< analytics::NPVCube > &outputCube, QuantLib::ext::shared_ptr< analytics::NPVCube > &outputCubeSensis, const QuantLib::Date &d, const QuantLib::Size cubeDateIndex, const QuantLib::Size sample, const std::string &label="")

void	runCalculators (bool isCloseOutDate, const std::map< std::string, QuantLib::Size > &counterparties, const std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > > &calculators, QuantLib::ext::shared_ptr< analytics::NPVCube > &cptyCube, const QuantLib::Date &d, const QuantLib::Size cubeDateIndex, const QuantLib::Size sample)

void	tradeExercisable (bool enable, const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &trades)

Private Attributes
QuantLib::Date	today_

QuantLib::ext::shared_ptr< ore::data::DateGrid >	dg_

QuantLib::ext::shared_ptr< ore::analytics::SimMarket >	simMarket_

set< std::pair< std::string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > >	modelBuilders_

Detailed Description

Valuation Engine.

The valuation engine's purpose is to generate an NPV cube. Its buildCube loops over samples->dates->trades and prices the portfolio under all samples and dates.

The number of dates is defined by the DateGrid passed to the constructor. The number of trades is defined by the size of the portfolio passed to buildCube(). The number of samples is defined by the NPVCube that is passed to buildCube(), this can be dynamic.

In addition to storing the resulting NPVs it can be given any number of calculators that can store additional values in the cube.

Definition at line 69 of file valuationengine.hpp.

Constructor & Destructor Documentation

◆ ValuationEngine()

ValuationEngine	(	const QuantLib::Date &	today,
		const QuantLib::ext::shared_ptr< ore::data::DateGrid > &	dg,
		const QuantLib::ext::shared_ptr< analytics::SimMarket > &	simMarket,
		const set< std::pair< std::string, QuantLib::ext::shared_ptr< QuantExt::ModelBuilder > > > &	modelBuilders = `set<std::pair<std::string, QuantLib::ext::shared_ptr<QuantExt::ModelBuilder>>>()`
	)

Constructor.

Parameters

today	Valuation date
dg	Simulation date grid
simMarket	Simulated market object
modelBuilders	model builders to be updated

Definition at line 49 of file valuationengine.cpp.

    : today_(today), dg_(dg), simMarket_(simMarket), modelBuilders_(modelBuilders) {
 
    QL_REQUIRE(dg_->size() > 0, "Error, DateGrid size must be > 0");
    QL_REQUIRE(today <= dg_->dates().front(), "ValuationEngine: Error today ("
                                                  << today << ") must not be later than first DateGrid date "
                                                  << dg_->dates().front());
    QL_REQUIRE(simMarket_, "ValuationEngine: Error, Null SimMarket");
}

Member Function Documentation

◆ buildCube()

void buildCube	(	const QuantLib::ext::shared_ptr< data::Portfolio > &	portfolio,
		QuantLib::ext::shared_ptr< analytics::NPVCube >	outputCube,
		std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > >	calculators,
		bool	mporStickyDate = `true`,
		QuantLib::ext::shared_ptr< analytics::NPVCube >	outputCubeNettingSet = `nullptr`,
		QuantLib::ext::shared_ptr< analytics::NPVCube >	outputCptyCube = `nullptr`,
		std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > >	cptyCalculators = `{}`,
		bool	dryRun = `false`
	)

Build NPV cube.

Parameters

portfolio	Portfolio to be priced
outputCube	Object for storing the results at trade level (e.g. NPVs, close-out NPVs, flows)
calculators	Calculators to use
mporStickyDate	Use sticky date in MPOR evaluation?
outputCubeNettingSet	Output cube for netting set-level results
outputCptyCube	Output cube for storing counterparty-level survival probabilities
cptyCalculators	Calculators for filling counterparty-level results
dryRun	Limit samples to one and fill the rest of the cube with random values

Definition at line 70 of file valuationengine.cpp.

                                                                                                                    {
 
    struct SimMarketResetter {
        SimMarketResetter(QuantLib::ext::shared_ptr<SimMarket> simMarket) : simMarket_(simMarket) {}
        ~SimMarketResetter() { simMarket_->reset(); }
        QuantLib::ext::shared_ptr<SimMarket> simMarket_;
    } simMarketResetter(simMarket_);
 
    LOG("Build cube with mporStickyDate=" << mporStickyDate << ", dryRun=" << std::boolalpha << dryRun);
 
    QL_REQUIRE(portfolio->size() > 0, "ValuationEngine: Error portfolio is empty");
 
    QL_REQUIRE(outputCube->numIds() == portfolio->trades().size(),
               "cube x dimension (" << outputCube->numIds() << ") "
                                    << "different from portfolio size (" << portfolio->trades().size() << ")");
 
    QL_REQUIRE(outputCube->numDates() == dg_->valuationDates().size(),
               "cube y dimension (" << outputCube->numDates() << ") "
                                    << "different from number of valuation dates (" << dg_->valuationDates().size()
                                    << ")");
 
    if (outputCptyCube) {
        QL_REQUIRE(outputCptyCube->numIds() == portfolio->counterparties().size() + 1,
                   "cptyCube x dimension (" << outputCptyCube->numIds() << "minus 1) "
                                            << "different from portfolio counterparty size ("
                                            << portfolio->counterparties().size() << ")");
 
        QL_REQUIRE(outputCptyCube->numDates() == dg_->dates().size(), "outputCptyCube y dimension ("
                                                                          << outputCptyCube->numDates() << ") "
                                                                          << "different from number of time steps ("
                                                                          << dg_->dates().size() << ")");
    }
 
    LOG("Starting ValuationEngine for " << portfolio->size() << " trades, " << outputCube->samples() << " samples and "
                                        << dg_->size() << " dates.");
 
    ObservationMode::Mode om = ObservationMode::instance().mode();
    Real updateTime = 0.0;
    Real pricingTime = 0.0;
    Real fixingTime = 0.0;
 
    LOG("Initialise " << calculators.size() << " valuation calculators");
    for (auto const& c : calculators) {
        c->init(portfolio, simMarket_);
        c->initScenario();
    }
 
    // Loop is Samples, Dates, Trades
    const auto& dates = dg_->dates();
    const auto& trades = portfolio->trades();
    auto& counterparties = outputCptyCube ? outputCptyCube->idsAndIndexes() : std::map<string, Size>();
    std::vector<bool> tradeHasError(portfolio->size(), false);
    LOG("Initialise state objects...");
    // initialise state objects for each trade (required for path-dependent derivatives in particular)
    size_t i = 0;
    for (const auto& [tradeId, trade] : trades) {
        QL_REQUIRE(!trade->npvCurrency().empty(), "NPV currency not set for trade " << trade->id());
 
        DLOG("Initialise wrapper for trade " << trade->id());
        trade->instrument()->initialise(dates);
 
        recalibrateModels();
 
        // T0 values
        try {
            for (auto& calc : calculators)
                calc->calculateT0(trade, i, simMarket_, outputCube, outputCubeNettingSet);
        } catch (const std::exception& e) {
            string expMsg = string("T0 valuation error: ") + e.what();
            StructuredTradeErrorMessage(tradeId, trade->tradeType(), "ScenarioValuation", expMsg.c_str()).log();
            tradeHasError[i] = true;
        }
 
        if (om == ObservationMode::Mode::Unregister) {
            for (const Leg& leg : trade->legs()) {
                for (Size n = 0; n < leg.size(); n++) {
                    QuantLib::ext::shared_ptr<FloatingRateCoupon> frc = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(leg[n]);
                    if (frc) {
                        frc->unregisterWith(frc->index());
                        trade->instrument()->qlInstrument()->unregisterWith(frc);
                        // Unregister with eval dates
                        frc->unregisterWith(Settings::instance().evaluationDate());
                        frc->index()->unregisterWith(Settings::instance().evaluationDate());
                        trade->instrument()->qlInstrument()->unregisterWith(Settings::instance().evaluationDate());
                    }
                }
            }
        }
        ++i;
    }
    LOG("Total number of trades = " << portfolio->size());
 
    if (!dates.empty() && dates.front() > simMarket_->asofDate()) {
        // the fixing manager is only required if sim dates contain future dates
        simMarket_->fixingManager()->initialise(portfolio, simMarket_);
    }
 
    cpu_timer timer;
    cpu_timer loopTimer;
    Size nTrades = trades.size();
 
    // We call Cube::samples() each time here to allow for dynamic stopping times
    // e.g. MC convergence tests
    for (Size sample = 0; sample < (dryRun ? std::min<Size>(1, outputCube->samples()) : outputCube->samples());
         ++sample) {
        TLOG("ValuationEngine: apply scenario sample #" << sample);
 
        for (auto& [tradeId, trade] : portfolio->trades())
            trade->instrument()->reset();
 
        // loop over Dates, increase cubeDateIndex for each valuation date we hit
        int cubeDateIndex = -1;
        if (!dg_->closeOutDates().empty() && mporStickyDate) {
            // loop over dates and always do value date and close out date in one run
            const bool scenarioUpdated = false;
            for (size_t i = 0; i < dg_->valuationDates().size(); ++i) {
                double priceTime = 0;
                double upTime = 0;
                ++cubeDateIndex;
                Date valueDate = dg_->valuationDates()[i];
                Date closeOutDate = dg_->closeOutDateFromValuationDate(valueDate);
                std::tie(priceTime, upTime) = populateCube(
                    valueDate, cubeDateIndex, sample, true, false, scenarioUpdated, trades, tradeHasError, calculators,
                    outputCube, outputCubeNettingSet, counterparties, cptyCalculators, outputCptyCube);
                pricingTime += priceTime;
                updateTime += upTime;
                if(closeOutDate != Date()){
                    std::tie(priceTime, upTime) = populateCube(
                        closeOutDate, cubeDateIndex, sample, false, mporStickyDate, scenarioUpdated, trades, tradeHasError,
                        calculators, outputCube, outputCubeNettingSet, counterparties, cptyCalculators, outputCptyCube);
                    pricingTime += priceTime;
                    updateTime += upTime;
                }
            }
        } else {
            std::map<Date, std::vector<size_t>> closeOutDateToValueDateIndex;
            for (Size i = 0; i < dates.size(); ++i) {
                Date d = dates[i];
                // Process auxiliary close-out dates first (may coincide with a valuation date, see below)
                // Store result at same cubeDateIndex as the corresponding valuation date's result, but at different
                // cube depth Differences to valuation date processing above: Update valuation date and fixings, trades
                // exercisable depending on stickiness
                bool scenarioUpdated = false;
                if (dg_->isCloseOutDate()[i]) {
                    double priceTime = 0;
                    double upTime = 0;
                    QL_REQUIRE(closeOutDateToValueDateIndex.count(d) == 1 && !closeOutDateToValueDateIndex[d].empty(),
                               "Need to calculate valuation date before close out date");
                    for (size_t& valueDateIndex : closeOutDateToValueDateIndex[d]) {
                        std::tie(priceTime, upTime) =
                            populateCube(d, valueDateIndex, sample, false, mporStickyDate, scenarioUpdated, trades,
                                         tradeHasError, calculators, outputCube, outputCubeNettingSet, counterparties,
                                         cptyCalculators, outputCptyCube);
                        pricingTime += priceTime;
                        updateTime += upTime;
                        scenarioUpdated = true;
                    }
                }
                if (dg_->isValuationDate()[i]) {
                    double priceTime = 0;
                    double upTime = 0;
                    ++cubeDateIndex;
                    Date closeOutDate = dg_->closeOutDateFromValuationDate(d);
                    if(closeOutDate != Date())
                        closeOutDateToValueDateIndex[closeOutDate].push_back(cubeDateIndex);
                    std::tie(priceTime, upTime) = populateCube(
                        d, cubeDateIndex, sample, true, false, scenarioUpdated, trades, tradeHasError, calculators,
                        outputCube, outputCubeNettingSet, counterparties, cptyCalculators, outputCptyCube);
                    pricingTime += priceTime;
                    updateTime += upTime;
                    scenarioUpdated = true;
                }
            }
        }
 
        std::ostringstream detail;
        detail << nTrades << " trade" << (nTrades == 1 ? "" : "s") << ", " << outputCube->samples() << " sample"
               << (outputCube->samples() == 1 ? "" : "s");
        updateProgress(sample * nTrades, outputCube->samples() * nTrades, detail.str());
 
        timer.start();
        simMarket_->fixingManager()->reset();
        fixingTime += timer.elapsed().wall * 1e-9;
    }
 
    if (dryRun) {
        LOG("Doing a dry run - fill remaining cube with random values.");
        for (Size sample = 1; sample < outputCube->samples(); ++sample) {
            for (Size i = 0; i < dates.size(); ++i) {
                for (Size j = 0; j < trades.size(); ++j) {
                    for (Size d = 0; d < outputCube->depth(); ++d) {
                        // add some noise, but only for the first few samples, so that e.g.
                        // a sensi run is not polluted with too many sensis for each trade
                        Real noise = sample < 10 ? static_cast<Real>(i + j + d + sample) : 0.0;
                        outputCube->set(outputCube->getT0(j, d) + noise, j, i, sample, d);
                    }
                }
            }
        }
    }
 
    std::ostringstream detail;
    detail << nTrades << " trade" << (nTrades == 1 ? "" : "s") << ", " << outputCube->samples() << " sample"
           << (outputCube->samples() == 1 ? "" : "s");
    updateProgress(outputCube->samples() * nTrades, outputCube->samples() * nTrades, detail.str());
    loopTimer.stop();
    LOG("ValuationEngine completed: loop " << setprecision(2) << loopTimer.format(2, "%w") << " sec, "
                                           << "pricing " << pricingTime << " sec, "
                                           << "update " << updateTime << " sec "
                                           << "fixing " << fixingTime);
 
    // for trades with errors set all output cube values to zero
    i = 0;
    for (auto& [tradeId, trade] : trades) {
        if (tradeHasError[i]) {
            ALOG("setting all results in output cube to zero for trade '"
                 << tradeId << "' since there was at least one error during simulation");
            outputCube->remove(i);
        }
        i++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recalibrateModels()

void recalibrateModels ( )

private

Definition at line 61 of file valuationengine.cpp.

                                        {
    ObservationMode::Mode om = ObservationMode::instance().mode();
    for (auto const& b : modelBuilders_) {
        if (om == ObservationMode::Mode::Disable)
            b.second->forceRecalculate();
        b.second->recalibrate();
    }
}

Here is the caller graph for this function:

◆ populateCube()

std::pair< double, double > populateCube	(	const QuantLib::Date &	d,
		size_t	cubeDateIndex,
		size_t	sample,
		bool	isValueDate,
		bool	isStickyDate,
		bool	scenarioUpdated,
		const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &	trades,
		std::vector< bool > &	tradeHasError,
		const std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > > &	calculators,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	outputCube,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	outputCubeNettingSet,
		const std::map< std::string, size_t > &	counterparties,
		const std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > > &	cptyCalculators,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	outputCptyCube
	)

private

Definition at line 355 of file valuationengine.cpp.

                                                             {
    double pricingTime = 0;
    double updateTime = 0;
    QL_REQUIRE(cubeDateIndex >= 0, "first date should be a valuation date");
    cpu_timer timer;
    timer.start();
    simMarket_->preUpdate();
    if (isValueDate || !isStickyDate) {
        simMarket_->updateDate(d);
    }
    // We can skip this step, if we have done that above in the close-out date section
    if (!scenarioUpdated) {
        simMarket_->updateScenario(d);
    }
    // Always with fixing update here, in contrast to the close-out date section
    simMarket_->postUpdate(d, !isStickyDate || isValueDate);
    // Aggregation scenario data update on valuation dates only
    if (isValueDate) {
        simMarket_->updateAsd(d);
    }
    recalibrateModels();
 
    timer.stop();
    updateTime += timer.elapsed().wall * 1e-9;
 
    timer.start();
    if (isStickyDate && !isValueDate) // switch on again, if sticky
        tradeExercisable(false, trades);
    // loop over trades
    runCalculators(!isValueDate, trades, tradeHasError, calculators, outputCube, outputCubeNettingSet, d, cubeDateIndex,
                   sample, simMarket_->label());
    if (isStickyDate && !isValueDate) // switch on again, if sticky
        tradeExercisable(true, trades);
    // loop over counterparty names
    if (isValueDate) {
        runCalculators(false, counterparties, cptyCalculators, outputCptyCube, d, cubeDateIndex, sample);
    }
    timer.stop();
    pricingTime += timer.elapsed().wall * 1e-9;
    return std::make_pair(pricingTime, updateTime);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ runCalculators() [1/2]

void runCalculators	(	bool	isCloseOutDate,
		const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &	trades,
		std::vector< bool > &	tradeHasError,
		const std::vector< QuantLib::ext::shared_ptr< ValuationCalculator > > &	calculators,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	outputCube,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	outputCubeSensis,
		const QuantLib::Date &	d,
		const QuantLib::Size	cubeDateIndex,
		const QuantLib::Size	sample,
		const std::string &	label = `""`
	)

private

Here is the caller graph for this function:

◆ runCalculators() [2/2]

void runCalculators	(	bool	isCloseOutDate,
		const std::map< std::string, QuantLib::Size > &	counterparties,
		const std::vector< QuantLib::ext::shared_ptr< CounterpartyCalculator > > &	calculators,
		QuantLib::ext::shared_ptr< analytics::NPVCube > &	cptyCube,
		const QuantLib::Date &	d,
		const QuantLib::Size	cubeDateIndex,
		const QuantLib::Size	sample
	)

private

◆ tradeExercisable()

void tradeExercisable	(	bool	enable,
		const std::map< std::string, QuantLib::ext::shared_ptr< ore::data::Trade > > &	trades
	)

private

Definition at line 343 of file valuationengine.cpp.

                                                                                                                 {
    for (const auto& [tradeId, trade] : trades) {
        auto t = QuantLib::ext::dynamic_pointer_cast<OptionWrapper>(trade->instrument());
        if (t != nullptr) {
            if (enable)
                t->enableExercise();
            else
                t->disableExercise();
        }
    }
}

Here is the caller graph for this function:

Member Data Documentation

◆ today_

QuantLib::Date today_

private

Definition at line 125 of file valuationengine.hpp.

◆ dg_

QuantLib::ext::shared_ptr<ore::data::DateGrid> dg_

private

Definition at line 126 of file valuationengine.hpp.

◆ simMarket_

QuantLib::ext::shared_ptr<ore::analytics::SimMarket> simMarket_

private

Definition at line 127 of file valuationengine.hpp.

◆ modelBuilders_

set<std::pair<std::string, QuantLib::ext::shared_ptr<QuantExt::ModelBuilder> > > modelBuilders_

private

Definition at line 128 of file valuationengine.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ValuationEngine()

Member Function Documentation

◆ buildCube()

◆ recalibrateModels()

◆ populateCube()

◆ runCalculators() [1/2]

◆ runCalculators() [2/2]

◆ tradeExercisable()

Member Data Documentation

◆ today_

◆ dg_

◆ simMarket_

◆ modelBuilders_