CashflowCalculator Class Reference

CashflowCalculator. More...

#include <orea/engine/valuationcalculator.hpp>

Inheritance diagram for CashflowCalculator:

Collaboration diagram for CashflowCalculator:

Public Member Functions
	CashflowCalculator (const std::string &baseCcyCode, const Date &t0Date, const QuantLib::ext::shared_ptr< DateGrid > &dateGrid, Size index)
	Constructor takes the base ccy, date grid and index of cube to write to. More...
virtual void	calculate (const QuantLib::ext::shared_ptr< Trade > &trade, Size tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &simMarket, QuantLib::ext::shared_ptr< NPVCube > &outputCube, QuantLib::ext::shared_ptr< NPVCube > &outputCubeNettingSet, const Date &date, Size dateIndex, Size sample, bool isCloseOut=false) override
virtual void	calculateT0 (const QuantLib::ext::shared_ptr< Trade > &trade, Size tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &simMarket, QuantLib::ext::shared_ptr< NPVCube > &outputCube, QuantLib::ext::shared_ptr< NPVCube > &outputCubeNettingSet) override
void	init (const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< SimMarket > &simMarket) override
void	initScenario () override
Public Member Functions inherited from ValuationCalculator
virtual	~ValuationCalculator ()
virtual void	calculate (const QuantLib::ext::shared_ptr< Trade > &trade, Size tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &simMarket, QuantLib::ext::shared_ptr< NPVCube > &outputCube, QuantLib::ext::shared_ptr< NPVCube > &outputCubeNettingSet, const Date &date, Size dateIndex, Size sample, bool isCloseOut=false)=0
virtual void	calculateT0 (const QuantLib::ext::shared_ptr< Trade > &trade, Size tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &simMarket, QuantLib::ext::shared_ptr< NPVCube > &outputCube, QuantLib::ext::shared_ptr< NPVCube > &outputCubeNettingSet)=0
virtual void	init (const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< SimMarket > &simMarket)=0
virtual void	initScenario ()=0

Private Attributes
std::string	baseCcyCode_
Date	t0Date_
QuantLib::ext::shared_ptr< DateGrid >	dateGrid_
Size	index_
std::vector< Handle< Quote > >	ccyQuotes_
std::vector< double >	fxRates_
std::vector< std::vector< Size > >	tradeAndLegCcyIndex_

Detailed Description

CashflowCalculator.

Calculates the cashflow, converted to base ccy, from t to t+1, this interval is defined by the provided dategrid The interval is (t, t+1], i.e. we exclude todays flows and include flows that fall exactly on t+1. For t0 we do nothing (and so the cube will have a 0 value)

Definition at line 121 of file valuationcalculator.hpp.

Constructor & Destructor Documentation

CashflowCalculator()

CashflowCalculator	(	const std::string &	baseCcyCode,
		const Date &	t0Date,
		const QuantLib::ext::shared_ptr< DateGrid > &	dateGrid,
		Size	index
	)

Constructor takes the base ccy, date grid and index of cube to write to.

Definition at line 124 of file valuationcalculator.hpp.

        : baseCcyCode_(baseCcyCode), t0Date_(t0Date), dateGrid_(dateGrid), index_(index) {}

Member Function Documentation

calculate()

void calculate ( const QuantLib::ext::shared_ptr< Trade > &  trade, Size  tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &  simMarket, QuantLib::ext::shared_ptr< NPVCube > &  outputCube, QuantLib::ext::shared_ptr< NPVCube > &  outputCubeNettingSet, const Date &  date, Size  dateIndex, Size  sample, bool  isCloseOut = false  )

overridevirtual

Implements ValuationCalculator.

Definition at line 109 of file valuationcalculator.cpp.

                                                                 {
    if (isCloseOut)
        return;
 
    Real netPositiveFlow = 0;
    Real netNegativeFlow = 0;
 
    QL_REQUIRE(dateGrid_->valuationDates()[dateIndex] == date, "Date mixup, date is " << date << " but grid index is "
                                                                             << dateIndex << ", grid(dateIndex) is "
                                                                             << dateGrid_->dates()[dateIndex]);
    // Date startDate = dateIndex == 0 ? t0Date_ : dateGrid_->dates()[dateIndex - 1];
    Date startDate = date;
    Date endDate = date == dateGrid_->dates().back() ? date : dateGrid_->dates()[dateIndex + 1];
 
    bool isOption = trade->instrument()->isOption();
    bool isExercised = false;
    bool isPhysical = false;
    Real longShort = 1.0;
    if (isOption) {
        QuantLib::ext::shared_ptr<data::OptionWrapper> wrapper =
            QuantLib::ext::dynamic_pointer_cast<data::OptionWrapper>(trade->instrument());
        isExercised = wrapper->isExercised();
        longShort = wrapper->isLong() ? 1.0 : -1.0;
        isPhysical = wrapper->isPhysicalDelivery();
    }
 
    try {
        if (!isOption || (isExercised && isPhysical)) {
            for (Size i = 0; i < trade->legs().size(); i++) {
                const Leg& leg = trade->legs()[i];
                Real legFlow = 0;
                for (auto flow : leg) {
                    // Take flows in (t, t+1]
                    if (startDate < flow->date() && flow->date() <= endDate)
                        legFlow += flow->amount();
                }
                if (legFlow != 0) {
                    // Do FX conversion and add to netFlow
                    Real fx = fxRates_[tradeAndLegCcyIndex_[tradeIndex][i]];
                    Real direction = trade->legPayers()[i] ? -1.0 : 1.0;
                    legFlow *= direction * longShort * fx;
                    if (legFlow > 0)
                        netPositiveFlow += legFlow;
                    else
                        netNegativeFlow += legFlow;
                }
            }
        }
    } catch (std::exception& e) {
        ALOG("Failed to calculate cashflows for trade " << trade->id() << " : " << e.what());
        netPositiveFlow = 0;
        netNegativeFlow = 0;
    } catch (...) {
        ALOG("Failed to calculate cashflows for trade " << trade->id() << " : Unhandled Exception");
        netPositiveFlow = 0;
        netNegativeFlow = 0;
    }
 
    Real numeraire = simMarket->numeraire();
 
    outputCube->set(netPositiveFlow / numeraire, tradeIndex, dateIndex, sample, index_);
    outputCube->set(netNegativeFlow / numeraire, tradeIndex, dateIndex, sample, index_+1);
}

Here is the call graph for this function:

calculateT0()

virtual void calculateT0 ( const QuantLib::ext::shared_ptr< Trade > &  trade, Size  tradeIndex, const QuantLib::ext::shared_ptr< SimMarket > &  simMarket, QuantLib::ext::shared_ptr< NPVCube > &  outputCube, QuantLib::ext::shared_ptr< NPVCube > &  outputCubeNettingSet  )

overridevirtual

Implements ValuationCalculator.

Definition at line 133 of file valuationcalculator.hpp.

                                                                                            {}

init()

void init ( const QuantLib::ext::shared_ptr< Portfolio > &  portfolio, const QuantLib::ext::shared_ptr< SimMarket > &  simMarket  )

overridevirtual

Implements ValuationCalculator.

Definition at line 79 of file valuationcalculator.cpp.

                                                                                 {
    DLOG("init CashflowCalculator");
    tradeAndLegCcyIndex_.clear();
    std::set<std::string> ccys;
    for (auto const& [tradeId,trade] : portfolio->trades()) {
        tradeAndLegCcyIndex_.push_back(std::vector<Size>(trade->legs().size()));
        for (auto const& l : trade->legCurrencies()) {
            ccys.insert(l);
        }
    }
    size_t i = 0;
    for (const auto& [tradeId, trade] : portfolio->trades()) {
        for (Size j = 0; j < trade->legs().size(); ++j) {
            tradeAndLegCcyIndex_[i][j] =
                std::distance(ccys.begin(), ccys.find(trade->legCurrencies()[j]));
        }
        i++;
    }
    ccyQuotes_.resize(ccys.size());
    for (Size i = 0; i < ccys.size(); ++i)
        ccyQuotes_[i] = (simMarket->fxRate(*std::next(ccys.begin(), i) + baseCcyCode_));
    fxRates_.resize(ccys.size());
}

Here is the call graph for this function:

initScenario()

void initScenario ( )

overridevirtual

Implements ValuationCalculator.

Definition at line 104 of file valuationcalculator.cpp.

                                      {
    for (Size i = 0; i < ccyQuotes_.size(); ++i)
        fxRates_[i] = ccyQuotes_[i]->value();
}

Member Data Documentation

baseCcyCode_

std::string baseCcyCode_

private

Definition at line 141 of file valuationcalculator.hpp.

t0Date_

Date t0Date_

private

Definition at line 142 of file valuationcalculator.hpp.

dateGrid_

QuantLib::ext::shared_ptr<DateGrid> dateGrid_

private

Definition at line 143 of file valuationcalculator.hpp.

index_

Size index_

private

Definition at line 144 of file valuationcalculator.hpp.

ccyQuotes_

std::vector<Handle<Quote> > ccyQuotes_

private

Definition at line 146 of file valuationcalculator.hpp.

fxRates_

std::vector<double> fxRates_

private

Definition at line 147 of file valuationcalculator.hpp.

tradeAndLegCcyIndex_

std::vector<std::vector<Size> > tradeAndLegCcyIndex_

private

Definition at line 148 of file valuationcalculator.hpp.