CommoditySwaptionBaseEngine Class Reference

Commodity Swaption Engine base class. More...

#include <qle/pricingengines/commodityswaptionengine.hpp>

Inheritance diagram for CommoditySwaptionBaseEngine:

Collaboration diagram for CommoditySwaptionBaseEngine:

Public Member Functions
	CommoditySwaptionBaseEngine (const Handle< YieldTermStructure > &discountCurve, const Handle< QuantLib::BlackVolTermStructure > &vol, Real beta=0.0)

Protected Member Functions
QuantLib::Size	fixedLegIndex () const
QuantLib::Real	fixedLegValue (QuantLib::Size fixedLegIndex) const
	Give back the fixed leg price at the swaption expiry time. More...
QuantLib::Real	strike (QuantLib::Size fixedLegIndex) const
QuantLib::Real	rho (const QuantLib::Date &ed_1, const QuantLib::Date &ed_2) const
bool	averaging (QuantLib::Size floatLegIndex) const

Protected Attributes
Handle< YieldTermStructure >	discountCurve_
Handle< QuantLib::BlackVolTermStructure >	volStructure_
Real	beta_

Detailed Description

Commodity Swaption Engine base class.

Correlation is parametrized as rho(s, t) = exp(-beta * abs(s - t)) where s and t are times to futures expiry. This is described in detail in the ORE+ Product Catalogue.

Definition at line 39 of file commodityswaptionengine.hpp.

Constructor & Destructor Documentation

CommoditySwaptionBaseEngine()

CommoditySwaptionBaseEngine	(	const Handle< YieldTermStructure > &	discountCurve,
		const Handle< QuantLib::BlackVolTermStructure > &	vol,
		Real	beta = 0.0
	)

Definition at line 77 of file commodityswaptionengine.cpp.

    : discountCurve_(discountCurve), volStructure_(vol), beta_(beta) {
    QL_REQUIRE(beta_ >= 0.0, "beta >= 0 required, found " << beta_);
    registerWith(discountCurve_);
    registerWith(volStructure_);
}

Member Function Documentation

fixedLegIndex()

Size fixedLegIndex ( ) const

protected

Performs checks on the underlying swap to ensure that:

• it has two legs with a commodity fixed leg against a commodity floating leg
• every cashflow on the commodity floating leg is either averaging or non-averaging Returns the index of the commodity fixed leg. Based on the checks, the commodity floating leg is the other leg.

Definition at line 85 of file commodityswaptionengine.cpp.

                                                      {
 
    Size fixedLegIndex = Null<Size>();
    bool haveFloatingLeg = false;
 
    QL_REQUIRE(arguments_.legs.size() == 2, "Two legs expected but found " << arguments_.legs.size());
 
    // Check both legs and populate the index of the fixed leg.
    for (Size i = 0; i < 2; i++) {
        QuantLib::ext::shared_ptr<CashFlow> cf = arguments_.legs[i].front();
        if (QuantLib::ext::shared_ptr<CommodityIndexedAverageCashFlow> flow =
                QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(cf)) {
            haveFloatingLeg = true;
            checkCashflows<CommodityIndexedAverageCashFlow>(arguments_.legs[i]);
        } else if (QuantLib::ext::shared_ptr<CommodityIndexedCashFlow> flow =
                       QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(cf)) {
            haveFloatingLeg = true;
            checkCashflows<CommodityIndexedCashFlow>(arguments_.legs[i]);
        } else {
            fixedLegIndex = i;
        }
    }
 
    QL_REQUIRE(haveFloatingLeg, "CommoditySwaptionBaseEngine: expected the swap to have a commodity floating leg");
    QL_REQUIRE(fixedLegIndex != Null<Size>(), "CommoditySwaptionBaseEngine: expected the swap to have a fixed leg");
 
    return fixedLegIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixedLegValue()

Real fixedLegValue ( QuantLib::Size  fixedLegIndex ) const

protected

Give back the fixed leg price at the swaption expiry time.

Definition at line 114 of file commodityswaptionengine.cpp.

                                                                        {
 
    // Return the commodity fixed leg value at the swaption expiry time.
    // This is the quantity K^{*} in the ORE+ Product Catalogue.
    Real value = 0.0;
 
    for (const QuantLib::ext::shared_ptr<CashFlow>& cf : arguments_.legs[fixedLegIndex]) {
        value += cf->amount() * discountCurve_->discount(cf->date());
    }
 
    Date exercise = arguments_.exercise->dateAt(0);
    Real discountExercise = discountCurve_->discount(exercise);
    value /= discountExercise;
 
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

strike()

Real strike ( QuantLib::Size  fixedLegIndex ) const

protected

Need a strike price when querying the volatility surface in certain calculations. We take this as the first fixed leg period amount divided by the first floating leg quantity.

Definition at line 131 of file commodityswaptionengine.cpp.

                                                                 {
 
    // First calculation period fixed leg amount
    Real amount = arguments_.legs[fixedLegIndex].front()->amount();
 
    // Divide by first calculation period floating leg (full calculation period) quantity
    Size idxFloat = fixedLegIndex == 0 ? 1 : 0;
    QuantLib::ext::shared_ptr<CashFlow> cf = arguments_.legs[idxFloat].front();
    if (QuantLib::ext::shared_ptr<CommodityIndexedCashFlow> ccf = QuantLib::ext::dynamic_pointer_cast<CommodityIndexedCashFlow>(cf)) {
        return amount / ccf->periodQuantity();
    } else if (QuantLib::ext::shared_ptr<CommodityIndexedAverageCashFlow> ccf =
                   QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(cf)) {
        return amount / ccf->periodQuantity();
    } else {
        QL_FAIL("Expected a CommodityIndexedCashFlow or CommodityIndexedAverageCashFlow");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rho()

Real rho ( const QuantLib::Date &  ed_1, const QuantLib::Date &  ed_2  ) const

protected

Return the correlation between two future expiry dates ed_1 and ed_2

Definition at line 149 of file commodityswaptionengine.cpp.

                                                                              {
 
    if (beta_ == 0.0 || ed_1 == ed_2) {
        return 1.0;
    } else {
        Time t_1 = volStructure_->timeFromReference(ed_1);
        Time t_2 = volStructure_->timeFromReference(ed_2);
        return exp(-beta_ * fabs(t_2 - t_1));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

averaging()

bool averaging ( QuantLib::Size  floatLegIndex ) const

protected

Return true if floating leg is averaging, otherwise false.

Definition at line 160 of file commodityswaptionengine.cpp.

                                                                    {
 
    // All cashflows in the floating leg have been checked for same type so just use first one here
    return static_cast<bool>(
        QuantLib::ext::dynamic_pointer_cast<CommodityIndexedAverageCashFlow>(arguments_.legs[floatLegIndex].front()));
}

Here is the caller graph for this function:

Member Data Documentation

discountCurve_

Handle<YieldTermStructure> discountCurve_

protected

Definition at line 69 of file commodityswaptionengine.hpp.

volStructure_

Handle<QuantLib::BlackVolTermStructure> volStructure_

protected

Definition at line 70 of file commodityswaptionengine.hpp.

beta_

Real beta_

protected

Definition at line 71 of file commodityswaptionengine.hpp.