/// <summary>
/// Initializes a new instance of the <see cref="PriceableBondCouponRateStream"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The client namespace.</param>
/// <param name="bondId">The bond Id.</param>
/// <param name="paymentConvention">The payment roll conventions</param>
/// <param name="forecastRateInterpolation">ForwardEndDate = forecastRateInterpolation ? AccrualEndDate
/// : AdjustedDateHelper.ToAdjustedDate(forecastRateIndex.indexTenor.Add(AccrualStartDate), AccrualBusinessDayAdjustments);</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="paymentCalendar">The paymentCalendar.</param>
/// <param name="tradeDate">The trade date is used to set the base date for future coupon generation.</param>
/// <param name="notionalAmount">The notional amount</param>
/// <param name="couponType">The coupon type: fixed or floating.</param>
/// <param name="bond">THe bond details.</param>
public PriceableBondCouponRateStream
(
ILogger logger
, ICoreCache cache
, string nameSpace
, string bondId
, DateTime tradeDate
, decimal notionalAmount
, CouponStreamType couponType
, Bond bond
, BusinessDayAdjustments paymentConvention
, bool forecastRateInterpolation
, IBusinessCalendar fixingCalendar
, IBusinessCalendar paymentCalendar)
{
BondId = bondId;
Multiplier = 1.0m;
PaymentCurrencies = new List <string>();
AnalyticsModel = new BondStreamAnalytic();
BondCouponStreamType = couponType;
Id = BuildId(bondId, BondCouponStreamType);
Currency = bond.currency.Value;
ForecastRateInterpolation = forecastRateInterpolation;
//Get the currency.
if (!PaymentCurrencies.Contains(bond.currency.Value))
{
PaymentCurrencies.Add(bond.currency.Value);
}
//The calendars
if (paymentCalendar == null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, paymentConvention.businessCenters, nameSpace);
}
//Set the default discount curve name.
BondCurveName = CurveNameHelpers.GetBondCurveName(Currency, bondId);
//Set the forecast curve name.//TODO extend this to the other types.
//if (BondCouponStreamType != CouponStreamType.GenericFixedRate)
//{
// if (fixingCalendar == null)
// {
// fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ResetDates.resetDatesAdjustments.businessCenters, nameSpace);
// }
// ForecastCurveName = null;
// //if (Calculation.Items != null)
// //{
// // var floatingRateCalculation = Calculation.Items;
// // var floatingRateIndex = (FloatingRateCalculation) floatingRateCalculation[0];
// // ForecastCurveName = CurveNameHelpers.GetForecastCurveName(floatingRateIndex);
// //}
//}
//Build the coupons and principal exchanges.
Coupons = PriceableInstrumentsFactory.CreatePriceableBondCoupons(tradeDate, bond, notionalAmount, BondCouponStreamType,
paymentConvention, ForecastRateInterpolation, fixingCalendar, paymentCalendar);//TODO add the stub calculation.
UpdateCouponDiscountCurveNames();
UpdateCouponIds();
//RiskMaturityDate = ;
logger.LogInfo("Bond Coupon Stream built");
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableSimpleBond"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="bond">The bond</param>
/// <param name="settlementDate">The settlement date.</param>
/// <param name="exDivDate">The ex dividend date.</param>
/// <param name="businessDayAdjustments">The business day adjustments.</param>
/// <param name="paymentCalendar">The payment Calendar.</param>
/// <param name="marketQuote">The market quote.</param>
/// <param name="quoteType">The quote type</param>
public PriceableSimpleBond(DateTime baseDate, Bond bond, DateTime settlementDate, DateTime exDivDate,
BusinessDayAdjustments businessDayAdjustments, IBusinessCalendar paymentCalendar, BasicQuotation marketQuote, BondPriceEnum quoteType)
: base(baseDate, bond.faceAmount, bond.currency, null, null, businessDayAdjustments, marketQuote, quoteType)
{
Id = bond.id;
var tempId = Id.Split('-');
var bondId = tempId[0];
if (tempId.Length > 2)
{
bondId = tempId[2];
}
Issuer = (string)bond.Item;//Does not handle PartyReference type -> only string!
Description = "Not Defined";
if (bond.description != null)
{
Description = bond.description;
}
MaturityDate = bond.maturity;
CouponDayCount = new DayCountFraction {
Value = bond.dayCountFraction.Value
};
if (bond.parValueSpecified)
{
ParValue = bond.parValue;
}
if (bond.couponRateSpecified)
{
CouponRate = bond.couponRate;
}
CouponFrequency = new Period
{
period = bond.paymentFrequency.period,
periodMultiplier = bond.paymentFrequency.periodMultiplier
};
CouponType = CouponTypeEnum.Fixed;
if (bond.clearanceSystem != null)
{
ClearanceSystem = bond.clearanceSystem.Value;
}
if (bond.exchangeId != null)
{
Exchange = bond.exchangeId.Value;
}
if (bond.seniority != null)
{
Seniority = EnumHelper.Parse <CreditSeniorityEnum>(bond.seniority.Value);
}
if (bond.instrumentId != null)
{
InstrumentIds = new List <InstrumentId>();
foreach (var identifier in bond.instrumentId.Select(id => InstrumentIdHelper.Parse(id.Value)))
{
InstrumentIds.Add(identifier);
}
}
//This handles the case of a bond forward used in curve building.
if (MaturityDate > BaseDate)
{
var rollConvention =
RollConventionEnumHelper.Parse(MaturityDate.Day.ToString(CultureInfo.InvariantCulture));
Frequency = FrequencyHelper.ToFrequency(bond.paymentFrequency);
SettlementDate = settlementDate;
UnAdjustedPeriodDates = DateScheduler.GetUnadjustedCouponDatesFromMaturityDate(SettlementDate,
MaturityDate,
CouponFrequency,
rollConvention,
out _,
out var nextCouponDate);
LastCouponDate = UnAdjustedPeriodDates[0];
NextCouponDate = nextCouponDate;
AdjustedPeriodDates =
AdjustedDateScheduler.GetAdjustedDateSchedule(UnAdjustedPeriodDates,
PaymentBusinessDayAdjustments.businessDayConvention,
paymentCalendar).ToArray();
AdjustedPeriodDates[0] = SettlementDate;
NextExDivDate = exDivDate;
IsXD = IsExDiv();
}
BondCurveName = CurveNameHelpers.GetBondCurveName(Currency.Value, bondId);
SwapDiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Currency.Value, true);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="tradeDate"></param>
/// <param name="settlementDate">The payment settlement date.</param>
/// <param name="settlementCalendar"></param>
/// <param name="paymentCalendar"></param>
/// <param name="bondFpML"></param>
/// <param name="basePartyReference"></param>
/// <param name="bondType"></param>
/// <param name="forecastRateInterpolation"></param>
public BondTransactionPricer(ILogger logger, ICoreCache cache, string nameSpace, DateTime tradeDate,
DateTime settlementDate, IBusinessCalendar settlementCalendar, IBusinessCalendar paymentCalendar,
BondTransaction bondFpML, string basePartyReference, string bondType, bool forecastRateInterpolation)
{
Multiplier = 1.0m;
TradeDate = tradeDate;
BondType = EnumHelper.Parse <BondTypesEnum>(bondType);
logger.LogInfo("BondType set. Commence to build a bond transaction.");
if (bondFpML == null)
{
return;
}
BuyerReference = bondFpML.buyerPartyReference.href;
PaymentCurrencies = new List <string> {
bondFpML.notionalAmount.currency.Value
};
SellerReference = bondFpML.sellerPartyReference.href;
BasePartyBuyer = basePartyReference == bondFpML.buyerPartyReference.href;
if (!BasePartyBuyer)
{
Multiplier = -1.0m;
}
ForecastRateInterpolation = forecastRateInterpolation;
SettlementCalendar = settlementCalendar;
PaymentCalendar = paymentCalendar;
//Set the bond price information
BondPrice = new BondPrice();
if (bondFpML.price.accrualsSpecified)
{
BondPrice.accrualsSpecified = true;
BondPrice.accruals = bondFpML.price.accruals;
}
if (bondFpML.price.dirtyPriceSpecified)
{
BondPrice.dirtyPriceSpecified = true;
BondPrice.dirtyPrice = bondFpML.price.dirtyPrice;
}
BondPrice.cleanOfAccruedInterest = bondFpML.price.cleanOfAccruedInterest;
BondPrice.cleanPrice = bondFpML.price.cleanPrice;
//Set the currencies
CouponCurrency = bondFpML.notionalAmount.currency;
PaymentCurrency = bondFpML.notionalAmount.currency;//This could be another currency!
//Set the notional information
NotionalAmount = MoneyHelper.GetAmount(bondFpML.notionalAmount.amount, bondFpML.notionalAmount.currency.Value);
//Determines the quotation and units
QuoteType = BondPriceEnum.YieldToMaturity;
//We need to get the ytm in until there is a bond market price/spread.
if (BondPrice.dirtyPriceSpecified)
{
QuoteType = BondPriceEnum.DirtyPrice;
Quote = BasicQuotationHelper.Create(BondPrice.dirtyPrice, RateQuotationType);
}
//Get the instrument configuration information.
var assetIdentifier = bondFpML.bond.currency.Value + "-Bond-" + BondType;
BondNodeStruct bondTypeInfo = null;
//TODO Set the swap curves for asset swap valuation.
//
//Gets the template bond type
var instrument = InstrumentDataHelper.GetInstrumentConfigurationData(cache, nameSpace, assetIdentifier);
if (instrument != null)
{
bondTypeInfo = instrument.InstrumentNodeItem as BondNodeStruct;
}
if (bondFpML.bond != null && bondTypeInfo != null)
{
if (SettlementCalendar == null)
{
SettlementCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, bondTypeInfo.SettlementDate.businessCenters, nameSpace);
}
if (PaymentCalendar == null)
{
PaymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, bondTypeInfo.BusinessDayAdjustments.businessCenters, nameSpace);
}
//Pre-processes the data for the priceable asset.
var bond = XmlSerializerHelper.Clone(bondFpML.bond);
Bond = bond;
bondTypeInfo.Bond = Bond;
//Set the curves to use for valuations.
BondCurveName = CurveNameHelpers.GetBondCurveName(Bond.currency.Value, Bond.id);
//THe discount curve is only for credit calculations.
DiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Bond.currency.Value, true);
if (bond.maturitySpecified)
{
MaturityDate = bond.maturity;
}
SettlementDateConvention = bondTypeInfo.SettlementDate;
BusinessDayAdjustments = bondTypeInfo.BusinessDayAdjustments;
ExDivDateConvention = bondTypeInfo.ExDivDate;
//This is done because the config data is not stored in the correct way. Need to add a price quote units.
if (bond.couponRateSpecified)
{
var coupon = bond.couponRate;
Bond.couponRate = coupon;
}
bondTypeInfo.Bond.faceAmount = NotionalAmount.amount;
bondTypeInfo.Bond.faceAmountSpecified = true;
Bond.faceAmount = NotionalAmount.amount;
if (Bond.maturitySpecified)
{
RiskMaturityDate = Bond.maturity;
}
SettlementDate = settlementDate;
if (!PaymentCurrencies.Contains(bondFpML.bond.currency.Value))
{
PaymentCurrencies.Add(bondFpML.bond.currency.Value);
}
logger.LogInfo("Bond transaction has been successfully created.");
}
else
{
logger.LogInfo("Bond type data not available.");
}
//Set the underlying bond
UnderlyingBond = new PriceableSimpleBond(tradeDate, bondTypeInfo, SettlementCalendar, PaymentCalendar, Quote, QuoteType);
BondIssuer = UnderlyingBond.Issuer;
if (BondPrice.dirtyPriceSpecified)
{
UnderlyingBond.PurchasePrice = BondPrice.dirtyPrice / 100; //PriceQuoteUnits
}
//Set the coupons
var bondId = Bond.id;//Could use one of the instrumentIds
//bondStream is an interest Rate Stream but needs to be converted to a bond stream.
//It automatically contains the coupon currency.
Coupons = new PriceableBondCouponRateStream(logger, cache, nameSpace, bondId, tradeDate,
bondFpML.notionalAmount.amount, CouponStreamType.GenericFixedRate, Bond,
BusinessDayAdjustments, ForecastRateInterpolation, null, PaymentCalendar);
//Add payments like the settlement price
if (!BondPrice.dirtyPriceSpecified)
{
return;
}
var amount = BondPrice.dirtyPrice * NotionalAmount.amount / 100;
var settlementPayment = PaymentHelper.Create(BuyerReference, SellerReference, PaymentCurrency.Value, amount, SettlementDate);
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, new[] { settlementPayment }, SettlementCalendar);
//
var finalPayment = PaymentHelper.Create(BondIssuer, BuyerReference, CouponCurrency.Value, NotionalAmount.amount, RiskMaturityDate);
FinalRedemption =
PriceableInstrumentsFactory.CreatePriceablePayment(basePartyReference, finalPayment, PaymentCalendar);
AdditionalPayments.Add(FinalRedemption);
if (!PaymentCurrencies.Contains(settlementPayment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(settlementPayment.paymentAmount.currency.Value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableSimpleBond"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="nodeStruct">The bond nodeStruct</param>
/// <param name="settlementCalendar">The settlement Calendar.</param>
/// <param name="paymentCalendar">The payment Calendar.</param>
/// <param name="marketQuote">The market quote.</param>
/// <param name="quoteType">THe quote Type</param>
public PriceableSimpleBond(DateTime baseDate, BondNodeStruct nodeStruct, IBusinessCalendar settlementCalendar, IBusinessCalendar paymentCalendar,
BasicQuotation marketQuote, BondPriceEnum quoteType)
: base(baseDate, nodeStruct.Bond.faceAmount, nodeStruct.Bond.currency, nodeStruct.SettlementDate, nodeStruct.ExDivDate, nodeStruct.BusinessDayAdjustments, marketQuote, quoteType)
{
Id = nodeStruct.Bond.id;
var tempId = Id.Split('-');
var bondId = tempId[0];
if (tempId.Length > 2)
{
bondId = tempId[2];
}
SettlementDateCalendar = settlementCalendar;
Issuer = (string)nodeStruct.Bond.Item;//Does not handle PartyReference type -> only string!
Description = "Not Defined";
//IsYTMQuote = true;
if (nodeStruct.Bond.description != null)
{
Description = nodeStruct.Bond.description;
}
MaturityDate = nodeStruct.Bond.maturity;
CouponDayCount = new DayCountFraction {
Value = nodeStruct.Bond.dayCountFraction.Value
};
CouponFrequency = new Period
{
period = nodeStruct.Bond.paymentFrequency.period,
periodMultiplier = nodeStruct.Bond.paymentFrequency.periodMultiplier
};
if (nodeStruct.Bond.couponRateSpecified)
{
CouponRate = nodeStruct.Bond.couponRate;
}
if (nodeStruct.Bond.parValueSpecified)
{
ParValue = nodeStruct.Bond.parValue;
}
if (nodeStruct.Bond.clearanceSystem != null)
{
ClearanceSystem = nodeStruct.Bond.clearanceSystem.Value;
}
if (nodeStruct.Bond.exchangeId != null)
{
Exchange = nodeStruct.Bond.exchangeId.Value;
}
CouponType = CouponTypeEnum.Fixed;
if (nodeStruct.Bond.seniority != null)
{
Seniority = EnumHelper.Parse <CreditSeniorityEnum>(nodeStruct.Bond.seniority.Value, true);
}
if (nodeStruct.Bond.instrumentId != null)
{
InstrumentIds = new List <InstrumentId>();
foreach (var identifier in nodeStruct.Bond.instrumentId.Select(id => InstrumentIdHelper.Parse(id.Value)))
{
InstrumentIds.Add(identifier);
}
}
//This handles the case of a bondforward used in curve building.
if (MaturityDate > BaseDate)
{
DateTime lastCouponDate;
DateTime nextCouponDate;
var rollConvention =
RollConventionEnumHelper.Parse(MaturityDate.Day.ToString(CultureInfo.InvariantCulture));
Frequency = FrequencyHelper.ToFrequency(nodeStruct.Bond.paymentFrequency);
//Get the settlement date
SettlementDate = GetSettlementDate(baseDate, settlementCalendar, nodeStruct.SettlementDate);
//Generate the necessary dates.
//TODO Should the settlement date and the underlying bond be calculated on the fly when calculation occurs?
UnAdjustedPeriodDates = DateScheduler.GetUnadjustedCouponDatesFromMaturityDate(SettlementDate,
MaturityDate,
CouponFrequency,
rollConvention,
out lastCouponDate,
out nextCouponDate);
LastCouponDate = UnAdjustedPeriodDates[0];
NextCouponDate = nextCouponDate;
AdjustedPeriodDates =
AdjustedDateScheduler.GetAdjustedDateSchedule(UnAdjustedPeriodDates,
nodeStruct.BusinessDayAdjustments
.businessDayConvention, paymentCalendar)
.ToArray();
AdjustedPeriodDates[0] = SettlementDate; //TODO check this!
NextExDivDate = GetNextExDivDate();
IsXD = IsExDiv();
}
BondCurveName = CurveNameHelpers.GetBondCurveName(Currency.Value, bondId);
SwapDiscountCurveName = CurveNameHelpers.GetDiscountCurveName(Currency.Value, true);
}