Pseudo Fixings Manager. More...

#include <orea/simulation/fixingmanager.hpp>

Collaboration diagram for FixingManager:

Public Types
using	FixingMap = std::map< QuantLib::ext::shared_ptr< Index >, std::set< Date >, detail::IndexComparator >
	Cashflow handler type definitions. More...

Public Member Functions
	FixingManager (Date today)

virtual	~FixingManager ()

void	initialise (const QuantLib::ext::shared_ptr< Portfolio > &portfolio, const QuantLib::ext::shared_ptr< Market > &market, const std::string &configuration=Market::defaultConfiguration)
	Initialise the manager with these flows and indices from the given portfolio. More...

void	update (Date d)
	Update fixings to date d. More...

void	reset ()
	Reset fixings to t0 (today) More...

Private Types
using	FixingCache = std::map< QuantLib::ext::shared_ptr< Index >, TimeSeries< Real >, detail::IndexComparator >

Private Member Functions
void	applyFixings (Date start, Date end)

Private Attributes
Date	today_

Date	fixingsEnd_

bool	modifiedFixingHistory_

FixingMap	fixingMap_

FixingCache	fixingCache_

Detailed Description

Pseudo Fixings Manager.

A Pseudo Fixing is a future historical fixing. When pricing on T0 but asof T and we require a fixing on t with T0 < t < T then the QuantLib pricing engines will look to the IndexManager for a fixing at t.

When moving between dates and simulation paths then the Fixings can change and should be populated in a path consistent manner

The FixingManager controls this updating and reset of the QuantLib::IndexManager for the required set of fixings

When stepping between simulation dated t_(n-1) and t_(n) and update a fixing t with t_(n-1) < t < t(n) than the fixing from t(n) will be backfilled. There is currently no interpolation of fixings.

Definition at line 57 of file fixingmanager.hpp.

Member Typedef Documentation

◆ FixingMap

using FixingMap = std::map<QuantLib::ext::shared_ptr<Index>, std::set<Date>, detail::IndexComparator>

Cashflow handler type definitions.

Definition at line 74 of file fixingmanager.hpp.

◆ FixingCache

using FixingCache = std::map<QuantLib::ext::shared_ptr<Index>, TimeSeries<Real>, detail::IndexComparator>

private

Definition at line 82 of file fixingmanager.hpp.

Constructor & Destructor Documentation

◆ FixingManager()

FixingManager ( Date today )

explicit

Definition at line 61 of file fixingmanager.cpp.

61: today_(today), fixingsEnd_(today), modifiedFixingHistory_(false) {}

ore::analytics::FixingManager::fixingsEnd_

Date fixingsEnd_

Definition: fixingmanager.hpp:79

ore::analytics::FixingManager::modifiedFixingHistory_

bool modifiedFixingHistory_

Definition: fixingmanager.hpp:80

ore::analytics::FixingManager::today_

Date today_

Definition: fixingmanager.hpp:79

◆ ~FixingManager()

virtual ~FixingManager ( )

virtual

Definition at line 60 of file fixingmanager.hpp.

60{}

Member Function Documentation

◆ initialise()

void initialise	(	const QuantLib::ext::shared_ptr< Portfolio > &	portfolio,
		const QuantLib::ext::shared_ptr< Market > &	market,
		const std::string &	configuration = `Market::defaultConfiguration`
	)

Initialise the manager with these flows and indices from the given portfolio.

Initialise the manager-.

Definition at line 65 of file fixingmanager.cpp.

                                                               {
 
    // populate the map "Index -> set of required fixing dates", where the index on the LHS is linked to curves
    for (auto const& [tradeId,t] : portfolio->trades()) {
        auto r = t->requiredFixings();
        r.unsetPayDates();
        for (auto const& [name, fixingDates] : r.fixingDatesIndices(QuantLib::Date::maxDate())) {
            std::set<Date> dates;
            for (const auto& [d, _] : fixingDates) {
                dates.insert(d);
            }
            try {
                auto rawIndex = parseIndex(name);
                if (auto index = QuantLib::ext::dynamic_pointer_cast<EquityIndex2>(rawIndex)) {
                    
                    fixingMap_[*market->equityCurve(index->familyName(), configuration)].insert(dates.begin(),
                                                                                                dates.end());
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<BondIndex>(rawIndex)) {
                    QL_FAIL("BondIndex not handled");
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<CommodityIndex>(rawIndex)) {
                    // for comm indices with non-daily expiries the expiry date's day of month is 1 always
                    Date safeExpiryDate = index->expiryDate();
                    if (safeExpiryDate != Date() && !index->keepDays()) {
                        safeExpiryDate = Date::endOfMonth(safeExpiryDate);
                    }
                    fixingMap_[index->clone(safeExpiryDate,
                                            market->commodityPriceCurve(index->underlyingName(), configuration))]
                        .insert(dates.begin(), dates.end());
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<FxIndex>(rawIndex)) {
                    fixingMap_[*market->fxIndex(index->oreName(), configuration)].insert(dates.begin(), dates.end());
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<GenericIndex>(rawIndex)) {
                    QL_FAIL("GenericIndex not handled");
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<ConstantMaturityBondIndex>(rawIndex)) {
                    QL_FAIL("ConstantMaturityBondIndex not handled");
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<IborIndex>(rawIndex)) {
                    fixingMap_[*market->iborIndex(name, configuration)].insert(dates.begin(), dates.end());
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<SwapIndex>(rawIndex)) {
                    fixingMap_[*market->swapIndex(name, configuration)].insert(dates.begin(), dates.end());
                } else if (auto index = QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndex>(rawIndex)) {
                    fixingMap_[*market->zeroInflationIndex(name, configuration)].insert(dates.begin(), dates.end());
                }
            } catch (const std::exception& e) {
                ALOG("FixingManager: error " << e.what() << " - no fixings are added for '" << name << "'");
            }
            TLOG("Added " << dates.size() << " fixing dates for '" << name << "'");
        }
    }
 
    // Now cache the original fixings so we can re-write on reset()
    for (auto const& m : fixingMap_) {
        fixingCache_[m.first] = IndexManager::instance().getHistory(m.first->name());
    }
}

Here is the call graph for this function:

◆ update()

void update ( Date d )

Update fixings to date d.

Definition at line 121 of file fixingmanager.cpp.

                                 {
    if (!fixingMap_.empty()) {
        QL_REQUIRE(d >= fixingsEnd_, "Can't go back in time, fixings must be reset."
                                     " Update date "
                                         << d << " but current fixings go to " << fixingsEnd_);
        if (d > fixingsEnd_)
            applyFixings(fixingsEnd_, d);
    }
    fixingsEnd_ = d;
}

Here is the call graph for this function:

◆ reset()

void reset ( )

Reset fixings to t0 (today)

Definition at line 133 of file fixingmanager.cpp.

                          {
    if (modifiedFixingHistory_) {
        for (auto& kv : fixingCache_)
            IndexManager::instance().setHistory(kv.first->name(), kv.second);
        modifiedFixingHistory_ = false;
    }
    fixingsEnd_ = today_;
}

◆ applyFixings()

void applyFixings	(	Date	start,
		Date	end
	)

private

Definition at line 142 of file fixingmanager.cpp.

                                                     {
    // Loop over all indices
    for (auto const& m : fixingMap_) {
        Date fixStart = start;
        Date fixEnd = end;
        Date currentFixingDate;
        if (auto zii = QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndex>(m.first)) {
            fixStart =
                inflationPeriod(fixStart - zii->zeroInflationTermStructure()->observationLag(), zii->frequency()).first;
            fixEnd =
                inflationPeriod(fixEnd - zii->zeroInflationTermStructure()->observationLag(), zii->frequency()).first +
                1;
            currentFixingDate = fixEnd;
        } else if (auto yii = QuantLib::ext::dynamic_pointer_cast<YoYInflationIndex>(m.first)) {
            fixStart =
                inflationPeriod(fixStart - yii->yoyInflationTermStructure()->observationLag(), yii->frequency()).first;
            fixEnd =
                inflationPeriod(fixEnd - yii->yoyInflationTermStructure()->observationLag(), yii->frequency()).first +
                1;
            currentFixingDate = fixEnd;
        } else {
            currentFixingDate = m.first->fixingCalendar().adjust(fixEnd, Following);
            // This date is a business day but may not be a valid fixing date in case of BMA/SIFMA
            if (!m.first->isValidFixingDate(currentFixingDate))
                currentFixingDate = nextValidFixingDate(currentFixingDate, m.first);
        }
 
        // Add we have a coupon between start and asof.
        bool needFixings = false;
        for (auto const& d : m.second) {
            if (d >= fixStart && d < fixEnd) {
                needFixings = true;
                break;
            }
        }
 
        if (needFixings) {
            Rate currentFixing;
            if (auto comm = QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityIndex>(m.first);
                comm != nullptr && comm->expiryDate() < currentFixingDate) {
                currentFixing = comm->priceCurve()->price(currentFixingDate);
            } else {
                currentFixing = m.first->fixing(currentFixingDate);
            }
            // if we read the fixing from an inverted FxIndex we have to undo the inversion
            TimeSeries<Real> history;
            for (auto const& d : m.second) {
                if (d >= fixStart && d < fixEnd) {
                    // Fixing dates include the valuation grid dates which might not be valid fixing dates (BMA/SIFMA)
                    bool valid = m.first->isValidFixingDate(d);
                    if (valid) {
                        history[d] = currentFixing;
                        modifiedFixingHistory_ = true;
                    }
                }
                if (d >= fixEnd)
                    break;
            }
            m.first->addFixings(history, true);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ today_

Date today_

private

Definition at line 79 of file fixingmanager.hpp.

◆ fixingsEnd_

Date fixingsEnd_

private

Definition at line 79 of file fixingmanager.hpp.

◆ modifiedFixingHistory_

bool modifiedFixingHistory_

private

Definition at line 80 of file fixingmanager.hpp.

◆ fixingMap_

FixingMap fixingMap_

private

Definition at line 84 of file fixingmanager.hpp.

◆ fixingCache_

FixingCache fixingCache_

private

Definition at line 85 of file fixingmanager.hpp.

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FixingMap

◆ FixingCache

Constructor & Destructor Documentation

◆ FixingManager()

◆ ~FixingManager()

Member Function Documentation

◆ initialise()

◆ update()

◆ reset()

◆ applyFixings()

Member Data Documentation

◆ today_

◆ fixingsEnd_

◆ modifiedFixingHistory_

◆ fixingMap_

◆ fixingCache_