CommodityFixedLegBuilder Class Reference

#include <ored/portfolio/commoditylegbuilder.hpp>

Inheritance diagram for CommodityFixedLegBuilder:

Collaboration diagram for CommodityFixedLegBuilder:

Public Member Functions
	CommodityFixedLegBuilder ()
QuantLib::Leg	buildLeg (const ore::data::LegData &data, const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &engineFactory, RequiredFixings &requiredFixings, const std::string &configuration, const QuantLib::Date &openEndDateReplacement=Null< Date >(), const bool useXbsCurves=false) const override
Public Member Functions inherited from LegBuilder
	LegBuilder (const string &legType)
virtual	~LegBuilder ()
virtual Leg	buildLeg (const LegData &data, const QuantLib::ext::shared_ptr< EngineFactory > &, RequiredFixings &requiredFixings, const string &configuration, const QuantLib::Date &openEndDateReplacement=Null< Date >(), const bool useXbsCurves=false) const =0
const string &	legType () const

Detailed Description

Definition at line 33 of file commoditylegbuilder.hpp.

Constructor & Destructor Documentation

CommodityFixedLegBuilder()

CommodityFixedLegBuilder

(

)

Definition at line 35 of file commoditylegbuilder.hpp.

: LegBuilder("CommodityFixed") {}

Member Function Documentation

buildLeg()

Leg buildLeg ( const ore::data::LegData &  data, const QuantLib::ext::shared_ptr< ore::data::EngineFactory > &  engineFactory, RequiredFixings &  requiredFixings, const std::string &  configuration, const QuantLib::Date &  openEndDateReplacement = Null<Date>(), const bool  useXbsCurves = false  ) const

override

Definition at line 311 of file commoditylegbuilder.cpp.

                                                                                                                  {
 
    // Check that our leg data has commodity fixed leg data
    auto fixedLegData = QuantLib::ext::dynamic_pointer_cast<CommodityFixedLegData>(data.concreteLegData());
    QL_REQUIRE(fixedLegData, "Wrong LegType, expected CommodityFixed, got " << data.legType());
 
    // Build our schedule and get the quantities and prices
    Schedule schedule = makeSchedule(data.schedule(),openEndDateReplacement);
    vector<Real> prices = buildScheduledVector(fixedLegData->prices(), fixedLegData->priceDates(), schedule);
    vector<Real> quantities = buildScheduledVector(fixedLegData->quantities(), fixedLegData->quantityDates(), schedule);
 
    // Build fixed rate leg with 1/1 day counter, prices as rates and quantities as notionals so that we have price x
    // notional in each period as the amount. We don't make any payment date adjustments yet as they come later.
    OneDayCounter dc;
    Leg fixedRateLeg = FixedRateLeg(schedule)
                           .withNotionals(quantities)
                           .withCouponRates(prices, dc)
                           .withPaymentAdjustment(Unadjusted)
                           .withPaymentLag(0)
                           .withPaymentCalendar(NullCalendar());
 
    // Get explicit payment dates which in most cases should be empty
    vector<Date> paymentDates;
    if (!data.paymentDates().empty()) {
        paymentDates = parseVectorOfValues<Date>(data.paymentDates(), &parseDate);
        if (fixedLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::FutureExpiryDate) {
            QL_REQUIRE(paymentDates.size() == fixedRateLeg.size(),
                       "Expected the number of payment dates derived from float leg with tag '"
                           << fixedLegData->tag() << "' (" << paymentDates.size()
                           << ") to equal the number of fixed price periods (" << fixedRateLeg.size()
                           << "). Are the leg schedules consistent? Should CommodityPayRelativeTo = FutureExpiryDate "
                              "be used?");
        } else {
            QL_REQUIRE(paymentDates.size() == fixedRateLeg.size(),
                       "Expected the number of explicit payment dates ("
                           << paymentDates.size() << ") to equal the number of fixed price periods ("
                           << fixedRateLeg.size() << ")");
        }
    }
 
    // Create the commodity fixed leg.
    Leg commodityFixedLeg;
    for (Size i = 0; i < fixedRateLeg.size(); i++) {
 
        auto cp = QuantLib::ext::dynamic_pointer_cast<FixedRateCoupon>(fixedRateLeg[i]);
 
        // Get payment date
        Date pmtDate;
        if (!paymentDates.empty()) {
            // Explicit payment dates were provided
            Calendar paymentCalendar =
                data.paymentCalendar().empty() ? NullCalendar() : parseCalendar(data.paymentCalendar());
            PaymentLag paymentLag = parsePaymentLag(data.paymentLag());
            Period paymentLagPeriod = boost::apply_visitor(PaymentLagPeriod(), paymentLag);
            BusinessDayConvention paymentConvention =
                data.paymentConvention().empty() ? Unadjusted : parseBusinessDayConvention(data.paymentConvention());
            pmtDate = paymentCalendar.advance(paymentDates[i], paymentLagPeriod, paymentConvention);
        } else {
            // Gather the payment conventions.
            BusinessDayConvention bdc =
                data.paymentConvention().empty() ? Following : parseBusinessDayConvention(data.paymentConvention());
 
            Calendar paymentCalendar =
                data.paymentCalendar().empty() ? schedule.calendar() : parseCalendar(data.paymentCalendar());
 
            PaymentLag payLag = parsePaymentLag(data.paymentLag());
            Period paymentLag = boost::apply_visitor(PaymentLagPeriod(), payLag);
 
            // Get unadjusted payment date based on pay relative to value.
            if (fixedLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::CalculationPeriodEndDate) {
                pmtDate = cp->accrualEndDate();
            } else if (fixedLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::CalculationPeriodStartDate) {
                pmtDate = cp->accrualStartDate();
            } else if (fixedLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::TerminationDate) {
                pmtDate = fixedRateLeg.back()->date();
            } else if (fixedLegData->commodityPayRelativeTo() == CommodityPayRelativeTo::FutureExpiryDate) {
                QL_FAIL("Internal error: commodity fixed leg builder can not determine payment date relative to future "
                        "expiry date, this has to be handled in the instrument builder.");
            } else {
                QL_FAIL("Unexpected value " << fixedLegData->commodityPayRelativeTo() << " for CommodityPayRelativeTo");
            }
 
            // Adjust the payment date using the payment conventions
            pmtDate = paymentCalendar.advance(pmtDate, paymentLag, bdc);
        }
 
        // Create the fixed cashflow for this period
        commodityFixedLeg.push_back(QuantLib::ext::make_shared<SimpleCashFlow>(cp->amount(), pmtDate));
    }
 
    applyIndexing(commodityFixedLeg, data, engineFactory, requiredFixings, openEndDateReplacement, useXbsCurves);
    addToRequiredFixings(commodityFixedLeg, QuantLib::ext::make_shared<FixingDateGetter>(requiredFixings));
 
    addToRequiredFixings(commodityFixedLeg, QuantLib::ext::make_shared<ore::data::FixingDateGetter>(requiredFixings));
 
    return commodityFixedLeg;
}

Here is the call graph for this function: