Serializable Bond-Basket Data. More...

#include <ored/portfolio/bondbasket.hpp>

Inheritance diagram for BondBasket:

Collaboration diagram for BondBasket:

Public Member Functions
	BondBasket ()
	Default constructor. More...

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

virtual XMLNode *	toXML (XMLDocument &doc) const =0

void	fromFile (const std::string &filename)

void	toFile (const std::string &filename) const

void	fromXMLString (const std::string &xml)
	Parse from XML string. More...

std::string	toXMLString () const
	Parse from XML string. More...

Serialisation
vector< QuantLib::ext::shared_ptr< Bond > >	bonds_

std::map< string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > >	fxIndexMap_

RequiredFixings	requiredFixings_

QuantLib::Date	reinvestment_

std::map< std::string, std::vector< double > >	reinvestmentScalar_

std::map< std::string, std::vector< std::string > >	flowType_

virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (ore::data::XMLDocument &doc) const override

std::map< AssetClass, std::set< std::string > >	underlyingIndices (const QuantLib::ext::shared_ptr< ReferenceDataManager > &referenceDataManager=nullptr) const
	Add underlying Bond names. More...

bool	empty ()

void	clear ()

QuantLib::ext::shared_ptr< QuantExt::BondBasket >	build (const QuantLib::ext::shared_ptr< EngineFactory > &engineFactory, const QuantLib::Currency &ccy, const std::string &reinvestmentEndDate)

const std::vector< QuantLib::ext::shared_ptr< Bond > > &	bonds () const

const RequiredFixings &	requiredFixings () const

bool	isFeeFlow (const ext::shared_ptr< QuantLib::CashFlow > &cf, const std::string &name)

void	setReinvestmentScalar ()

Detailed Description

Serializable Bond-Basket Data.

Definition at line 48 of file bondbasket.hpp.

Constructor & Destructor Documentation

◆ BondBasket()

BondBasket ( )

Default constructor.

Definition at line 51 of file bondbasket.hpp.

51{}

Member Function Documentation

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Implements XMLSerializable.

Definition at line 261 of file bondbasket.cpp.

                                      {
 
    clear();
 
    XMLUtils::checkNode(node, "BondBasketData");
    bonds_.clear();
    for (XMLNode* child = XMLUtils::getChildNode(node, "Trade"); child; child = XMLUtils::getNextSibling(child)) {
        string id = XMLUtils::getAttribute(child, "id");
        auto bonddata = QuantLib::ext::make_shared<ore::data::Bond>();
        bonddata->fromXML(child);
        bonddata->id() = id;
        bonds_.push_back(bonddata);
    }
}

◆ toXML()

XMLNode * toXML ( ore::data::XMLDocument & doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 276 of file bondbasket.cpp.

                                                        {
    XMLNode* node = doc.allocNode("BondBasketData");
    for (Size i = 0; i < bonds_.size(); i++) {
        XMLUtils::appendNode(node, bonds_[i]->toXML(doc));
    }
    return node;
}

Here is the call graph for this function:

◆ underlyingIndices()

std::map< AssetClass, std::set< std::string > > underlyingIndices ( const QuantLib::ext::shared_ptr< ReferenceDataManager > & referenceDataManager = nullptr ) const

Add underlying Bond names.

Definition at line 284 of file bondbasket.cpp.

                                                                                                                                                 {
    std::map<AssetClass, std::set<std::string>> result;
    result[AssetClass::BOND] = {};
    for ( auto b : bonds_)
        result[AssetClass::BOND].insert(b->bondData().securityId());
    return result;
}

◆ empty()

bool empty ( )

Definition at line 62 of file bondbasket.hpp.

62{ return bonds_.empty(); }

◆ clear()

void clear ( )

Definition at line 256 of file bondbasket.cpp.

                       {
 
    bonds_.clear();
}

◆ build()

QuantLib::ext::shared_ptr< QuantExt::BondBasket > build	(	const QuantLib::ext::shared_ptr< EngineFactory > &	engineFactory,
		const QuantLib::Currency &	ccy,
		const std::string &	reinvestmentEndDate
	)

Definition at line 56 of file bondbasket.cpp.

                                                                                             {
    DLOG("BondBasket::build() called");
 
    QuantLib::ext::shared_ptr<Pool> pool(new Pool());
    vector<Issuer> issuerPair;
    set<Currency> currencies_unique;
 
    map<string,  QuantLib::ext::shared_ptr<QuantLib::Bond>> qlBonds;
    map<string, double> recoveries;
    map<string, double> multipliers;
    map<string, Handle<YieldTermStructure>> yieldTermStructures;
    map<string, Currency> currencies;
 
    const QuantLib::ext::shared_ptr<Market> market = engineFactory->market();
 
    for (size_t i = 0; i < bonds_.size(); i++) {
        DLOG("BondBasket::build() -- processing issuer number " << i);
 
        bonds_[i]->build(engineFactory);
        string creditId = bonds_[i]->bondData().creditCurveId();
        string securityId = bonds_[i]->bondData().securityId();
 
        Handle<DefaultProbabilityTermStructure> defaultOriginal =
            securitySpecificCreditCurve(market, securityId, creditId)->curve();
        Handle<DefaultProbabilityTermStructure> defaultTS;
        Handle<Quote> recovery;
        try {
            recovery = market->recoveryRate(securityId, Market::defaultConfiguration);
        } catch (...) {
        }
 
        try {
 
            Real rr = recovery.empty() ? 0.0 : recovery->value();
            auto m = [rr](Real x) { return x / (1.0 - rr); };
            Handle<Quote> scaledSpread(QuantLib::ext::make_shared<DerivedQuote<decltype(m)>>(
                market->securitySpread(securityId, Market::defaultConfiguration), m));
 
            defaultTS = Handle<DefaultProbabilityTermStructure>(
                    QuantLib::ext::make_shared<QuantExt::HazardSpreadedDefaultTermStructure>(defaultOriginal, scaledSpread));
 
            bonds_[i]->instrument()->qlInstrument()->registerWith(scaledSpread);
            recoveries[bonds_[i]->id()] = rr;
 
        } catch (...) {
            defaultTS = defaultOriginal;
            recoveries[bonds_[i]->id()] = 0.0;
        }
 
 
        issuerPair.push_back(dummyIssuer(defaultTS));
        pool->add(bonds_[i]->id(), issuerPair[i]);
        currencies_unique.insert(parseCurrency(bonds_[i]->bondData().currency()));
        requiredFixings_.addData(bonds_[i]->requiredFixings());
 
        QuantLib::ext::shared_ptr<QuantLib::Bond> qlBond = QuantLib::ext::dynamic_pointer_cast<QuantLib::Bond>(bonds_[i]->instrument()->qlInstrument());
        QL_REQUIRE(qlBond, "ql bond expected " << bonds_[i]->id());
        qlBonds[bonds_[i]->id()]= qlBond;
 
        multipliers[bonds_[i]->id()] = bonds_[i]->instrument()->multiplier();
        yieldTermStructures[bonds_[i]->id()] = market->discountCurve(bonds_[i]->bondData().currency());
        currencies[bonds_[i]->id()] = parseCurrency(bonds_[i]->bondData().currency());
 
    }
 
    DLOG("pool names");
    for (size_t i = 0; i < pool->names().size(); i++) {
        DLOG("name: " << pool->names()[i] << ", included: " << pool->has(bonds_[i]->id()));
    }
 
    //create a fx index map for each requred currency...
    for (auto it = currencies_unique.begin(); it!=currencies_unique.end(); ++it){
        if(it->code() != baseCcy.code()){
            string source = it->code();
            string target = baseCcy.code();
            Handle<YieldTermStructure> sorTS = market->discountCurve(source);
            Handle<YieldTermStructure> tarTS = market->discountCurve(target);
            Handle<Quote> spot = market->fxSpot(source + target);
            Calendar cal = NullCalendar();
            Natural fixingDays = 0;
 
            string name = source + target + "Index";
 
            QuantLib::ext::shared_ptr<QuantExt::FxIndex> fxi = QuantLib::ext::make_shared<QuantExt::FxIndex>(
                name, fixingDays, parseCurrency(source), baseCcy, cal, spot, sorTS, tarTS);
 
            fxIndexMap_[source] = fxi;
 
            DLOG("BondBasket::build() -- created FX Index for " << source + target);
        }
    }
 
    reinvestment_ = Date().minDate();
    if(reinvestmentEndDate != "")
        reinvestment_ = ore::data::parseDate(reinvestmentEndDate);
 
    setReinvestmentScalar();
 
    QuantLib::ext::shared_ptr<QuantExt::BondBasket> basket(
        new QuantExt::BondBasket(qlBonds, recoveries, multipliers, yieldTermStructures, currencies,
                                    pool, baseCcy, fxIndexMap_, reinvestment_, reinvestmentScalar_, flowType_));
 
    DLOG("BondBasket::build() -- completed");
 
    return basket;
}

Here is the call graph for this function:

◆ bonds()

const std::vector< QuantLib::ext::shared_ptr< Bond > > & bonds ( ) const

Definition at line 70 of file bondbasket.hpp.

70{ return bonds_; }

◆ requiredFixings()

const RequiredFixings & requiredFixings ( ) const

Definition at line 72 of file bondbasket.hpp.

72{ return requiredFixings_; }

◆ isFeeFlow()

bool isFeeFlow	(	const ext::shared_ptr< QuantLib::CashFlow > &	cf,
		const std::string &	name
	)

private

Definition at line 165 of file bondbasket.cpp.

                                                                                           {
 
        //in order to identify as fees, the method expects, (upfront) fees in the form of CashflowData legdata within xml representation
        //this could be dangerous, as 5% upfront and 5% amortisation at the same date could trigger wrong assessment
 
        bool result = false;
        for(auto& bond : bonds_){
            if(bond->id() == name){
                auto oreBondData = QuantLib::ext::make_shared<ore::data::BondData>(bond->bondData());
                if(oreBondData){
                    for (auto legData : oreBondData->coupons()){
                        auto cfData = QuantLib::ext::dynamic_pointer_cast<ore::data::CashflowData>(legData.concreteLegData());
                        if(cfData){
                            auto amounts = cfData->amounts();
                            auto dates = cfData->dates();
                            for(size_t d = 0; d < dates.size(); d++){
                                if(cf->date() == ore::data::parseDate(dates[d])){
                                    if(cf->amount() == amounts[d])
                                        result = true;
                                }
                            }
                        }
                    }
                }
            }
        }
        return result;
    }

Here is the call graph for this function:

◆ setReinvestmentScalar()

void setReinvestmentScalar ( )

private

Definition at line 194 of file bondbasket.cpp.

                                      {
 
    Date today = Settings::instance().evaluationDate();
 
    for(auto& bond : bonds_){
 
        string name = bond->id();
        if(bond->maturity() <=  reinvestment_)
            ALOG("bond " << name << " maturity " << io::iso_date(bond->maturity()) << " <= " << "reinvestment end " << io::iso_date(reinvestment_));
 
        //identify adjustment factor (scalars) -> rescale to todays notional
        const vector<Leg>& legs = bond->legs();
        if(legs.size() > 1)
            ALOG("bond " << name << " has more than one leg, only the first is considered.")
        const Leg& leg = legs[0];
 
        size_t jmax = 0;    //index for first coupon date after reinvestment period end date
        for (size_t j = 0; j < leg.size(); j++) {
            QuantLib::ext::shared_ptr<QuantLib::Coupon> ptrCoupon =
                QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(leg[j]);
            if(ptrCoupon){
                if(ptrCoupon->date() > reinvestment_){
                    jmax = j;
                    break;
                }
            }
        }
 
        double baseNotional = bond->notional(); //notional as of today, as set in the ore::data::Bond::build
        vector<double>scalars(leg.size(), 1.0);
        vector<string>flowType(leg.size(), "");
        double currentScalar = 1.0;
 
        for (size_t j = 0; j < leg.size(); j++) {
 
            QuantLib::ext::shared_ptr<QuantLib::Coupon> ptrCoupon =
                QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(leg[j]);
            flowType[j] = "xnl"; //notional
            if(isFeeFlow(leg[j], name))
                flowType[j] = "fee"; //fees
 
            if(ptrCoupon){
                flowType[j] = "int"; //interest
                if(j <= jmax && ptrCoupon->date() >= today){
                    double periodNotional = ptrCoupon->nominal();
 
                    if(periodNotional < 1e-10)
                        ALOG(name <<  " amortises too early: periodNotional " << periodNotional
                            << " cpnDate " << io::iso_date(ptrCoupon->date())
                            << " (first period after) reinvestment end " << io::iso_date(reinvestment_));
 
                    if(periodNotional < baseNotional && periodNotional > 1e-10)
                        currentScalar = baseNotional/periodNotional;
                }
            }
            scalars[j] = currentScalar;
        }
        reinvestmentScalar_[name] = scalars;
        flowType_[name] = flowType;
    }
}

Here is the call graph for this function:

Member Data Documentation

◆ bonds_

vector<QuantLib::ext::shared_ptr<Bond> > bonds_

private

Definition at line 78 of file bondbasket.hpp.

◆ fxIndexMap_

std::map<string, QuantLib::ext::shared_ptr<QuantExt::FxIndex> > fxIndexMap_

private

Definition at line 79 of file bondbasket.hpp.

◆ requiredFixings_

RequiredFixings requiredFixings_

private

Definition at line 80 of file bondbasket.hpp.

◆ reinvestment_

QuantLib::Date reinvestment_

private

Definition at line 81 of file bondbasket.hpp.

◆ reinvestmentScalar_

std::map<std::string, std::vector<double> > reinvestmentScalar_

private

Definition at line 82 of file bondbasket.hpp.

◆ flowType_

std::map<std::string, std::vector<std::string> > flowType_

private

Definition at line 83 of file bondbasket.hpp.

Public Member Functions

Serialisation

Detailed Description

Constructor & Destructor Documentation

◆ BondBasket()

Member Function Documentation

◆ fromXML()

◆ toXML()

◆ underlyingIndices()

◆ empty()

◆ clear()

◆ build()

◆ bonds()

◆ requiredFixings()

◆ isFeeFlow()

◆ setReinvestmentScalar()

Member Data Documentation

◆ bonds_

◆ fxIndexMap_

◆ requiredFixings_

◆ reinvestment_

◆ reinvestmentScalar_

◆ flowType_