/// <summary>
/// A slightly ore complicated date scheduler.
/// </summary>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="rollsMetaSchedule"></param>
/// <param name="backwardGeneration"></param>
/// <param name="businessDayAdjustments"></param>
/// <param name="businessCalendar"></param>
/// <returns></returns>
public static List <DateTime> GetAdjustedDates3(DateTime startDate, DateTime endDate, List <MetaScheduleItem> rollsMetaSchedule,
bool backwardGeneration, BusinessDayAdjustments businessDayAdjustments, IBusinessCalendar businessCalendar)
{
var unadjustedDates = DatesMetaSchedule.GetUnadjustedDates3(startDate, endDate, rollsMetaSchedule, backwardGeneration);
return(unadjustedDates.Select(date => AdjustedDateHelper.ToAdjustedDate(businessCalendar, date, businessDayAdjustments)).ToList());
}
///<summary>
/// Gets the adjusted dates from a provided date schedule.
///</summary>
///<param name="metaScheduleDefinition"></param>
///<param name="startDate"></param>
///<param name="businessDayAdjustments"></param>
///<param name="businessCalendar"></param>
///<returns></returns>
public static List <DateTime> GetAdjustedDates(List <Triplet <Period, Period, RollConventionEnum> > metaScheduleDefinition,
DateTime startDate, BusinessDayAdjustments businessDayAdjustments, IBusinessCalendar businessCalendar)
{
var unadjustedDates = DatesMetaSchedule.GetUnadjustedDates(metaScheduleDefinition, startDate);
return(unadjustedDates.Select(date => AdjustedDateHelper.ToAdjustedDate(businessCalendar, date, businessDayAdjustments)).ToList());
}
private static void GeneratePeriodsBackward(DateTime firstRollDate, CalculationPeriodFrequency frequency,
BusinessDayAdjustments calculationPeriodDatesAdjustments,
CalculationPeriodsPrincipalExchangesAndStubs result,
DateTime adjustedEffectiveDate, StubPeriodTypeEnum?initialStubType
, IBusinessCalendar paymentCalendar)
{
DateTime periodEndDate = firstRollDate;
DateTime periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1);
bool encounteredShortInitialStub = false;
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, calculationPeriodDatesAdjustments.businessCenters);
//}
do
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
DateTime rollConventionAdjustedPeriodStartDate = periodStartDate;
DateTime rollConventionAdjustedPeriodEndDate = periodEndDate;
var frequencyPeriod = EnumHelper.Parse <PeriodEnum>(frequency.period, true);
if (frequencyPeriod != PeriodEnum.D)//adjust if the frequency is NOT expressed in days
{
rollConventionAdjustedPeriodStartDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodStartDate);
rollConventionAdjustedPeriodEndDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodEndDate);
}
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, rollConventionAdjustedPeriodStartDate, rollConventionAdjustedPeriodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionAdjustedPeriodStartDate, calculationPeriodDatesAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionAdjustedPeriodEndDate, calculationPeriodDatesAdjustments);
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
//if (calculationPeriod.unadjustedStartDate > adjustedEffectiveDate)
if (calculationPeriod.adjustedStartDate > adjustedEffectiveDate)
{
result.InsertFirst(calculationPeriod);
periodEndDate = periodStartDate;
periodStartDate = AddPeriod(periodEndDate, IntervalHelper.FromFrequency(frequency), -1);
}
//else if (calculationPeriod.unadjustedStartDate == adjustedEffectiveDate)//first period - not stub
else if (calculationPeriod.adjustedStartDate == adjustedEffectiveDate)//first period - not stub
{
result.InsertFirst(calculationPeriod);
break;
}
else//first period - short stub (merge with next period if a long stub specified)
{
encounteredShortInitialStub = true;
//calculationPeriod.unadjustedStartDate = adjustedEffectiveDate;
calculationPeriod.adjustedStartDate = adjustedEffectiveDate;
result.InitialStubCalculationPeriod = calculationPeriod;
break;
}
} while (true);
if (encounteredShortInitialStub && initialStubType == StubPeriodTypeEnum.LongInitial)
{
result.CreateLongInitialStub();
}
}
private static CalculationPeriod Create(DateTime periodStartDate, DateTime periodEndDate
, CalculationPeriodFrequency frequency, BusinessDayAdjustments dateAdjustments
, IBusinessCalendar paymentCalendar, bool isFirstPeriodCreated)
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
DateTime rollConventionPeriodStartDate = periodStartDate;
DateTime rollConventionPeriodEndDate = periodEndDate;
var frequencyPeriod = EnumHelper.Parse <PeriodEnum>(frequency.period, true);
if (frequencyPeriod != PeriodEnum.D)//adjust if the frequency is NOT expressed in days
{
rollConventionPeriodStartDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodStartDate);
rollConventionPeriodEndDate = RollConventionEnumHelper.AdjustDate(frequency.rollConvention, periodEndDate);
}
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, rollConventionPeriodStartDate, rollConventionPeriodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionPeriodStartDate, dateAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, rollConventionPeriodEndDate, dateAdjustments);
if (isFirstPeriodCreated)
{
adjustedPeriodEndDate = periodEndDate;
}
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
return(calculationPeriod);
}
/// <summary>
/// A simple date scheduler.
/// </summary>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="interval"></param>
/// <param name="rollConventionEnum"></param>
/// <param name="backwardGeneration"></param>
/// <param name="businessDayAdjustments"></param>
/// <param name="businessCalendar"></param>
/// <returns></returns>
public static List <DateTime> GetAdjustedDates2(DateTime startDate, DateTime endDate, Period interval, RollConventionEnum rollConventionEnum,
bool backwardGeneration, BusinessDayAdjustments businessDayAdjustments, IBusinessCalendar businessCalendar)
{
var unadjustedDates = DatesMetaSchedule.GetUnadjustedDates2(startDate, endDate, interval, rollConventionEnum, backwardGeneration);
return(unadjustedDates.Select(date => AdjustedDateHelper.ToAdjustedDate(businessCalendar, date, businessDayAdjustments)).ToList());
}
/// <summary>
/// </summary>
/// <param name="cache"></param>
/// <param name="interestRateStream"></param>
/// <param name="listCalculationPeriods"></param>
/// <param name="fixingCalendar"></param>
/// <param name="nameSpace"></param>
/// <returns></returns>
/// <exception cref="NotSupportedException"></exception>
/// <exception cref="NotImplementedException"></exception>
public static List <DateTime> GetAdjustedResetDates(ICoreCache cache, InterestRateStream interestRateStream,
List <CalculationPeriod> listCalculationPeriods, IBusinessCalendar fixingCalendar, string nameSpace)
{
var adjustedResetDates = new List <DateTime>();
ResetDates resetDates = interestRateStream.resetDates;
Period resetFrequency = IntervalHelper.FromFrequency(resetDates.resetFrequency);
Period calculationPeriodFrequency = IntervalHelper.FromFrequency(interestRateStream.calculationPeriodDates.calculationPeriodFrequency);
if (resetFrequency.period != calculationPeriodFrequency.period)
{
throw new NotSupportedException(
$"Reset period type ({resetFrequency.period}) and calculation period type ({calculationPeriodFrequency.period}) are different. This is not supported.");
}
if (int.Parse(resetFrequency.periodMultiplier) != int.Parse(calculationPeriodFrequency.periodMultiplier))
{
throw new NotSupportedException(
$"Reset period frequency ({resetFrequency.period}) is not equal to calculation period frequency ({calculationPeriodFrequency.period}). This is not supported.");
}
BusinessDayAdjustments resetDatesAdjustments = resetDates.resetDatesAdjustments;
ResetRelativeToEnum resetRelativeTo = resetDates.resetRelativeTo;
if (fixingCalendar == null)
{
fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, resetDatesAdjustments.businessCenters, nameSpace);
}
foreach (CalculationPeriod calculationPeriodsInPaymentPeriod in listCalculationPeriods)
{
switch (resetRelativeTo)
{
case ResetRelativeToEnum.CalculationPeriodStartDate:
{
DateTime unadjustedResetDate = calculationPeriodsInPaymentPeriod.unadjustedStartDate;
DateTime adjustedResetDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, unadjustedResetDate, resetDatesAdjustments);
adjustedResetDates.Add(adjustedResetDate);
break;
}
case ResetRelativeToEnum.CalculationPeriodEndDate:
{
DateTime unadjustedResetDate = calculationPeriodsInPaymentPeriod.unadjustedEndDate;
DateTime adjustedResetDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, unadjustedResetDate, resetDatesAdjustments);
adjustedResetDates.Add(adjustedResetDate);
break;
}
default:
{
throw new NotImplementedException("resetRelativeTo");
}
}
}
return(adjustedResetDates);
}
private static DateTime CalculatePaymentDate(PaymentDates paymentDates,
PayRelativeToEnum payRelativeTo,
IList <CalculationPeriod> calculationPeriodsInPamentPeriod,
Offset paymentDaysOffset,
BusinessDayAdjustments paymentDatesBusinessDayAdjustments,
IBusinessCalendar paymentCalendar)
{
switch (payRelativeTo)
{
case PayRelativeToEnum.CalculationPeriodStartDate:
{
// To get the calculation period start date - obtain a reference to FIRST calculation period in the payment period.
//
CalculationPeriod firstCalculatinPeriodInPaymentPeriod = calculationPeriodsInPamentPeriod[0];
BusinessDayAdjustments paymentDatesAdjustments = paymentDates.paymentDatesAdjustments;
// Adjust using paymentDatesAdjustments...
//
DateTime adjustedPaymentDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, firstCalculatinPeriodInPaymentPeriod.unadjustedStartDate, paymentDatesAdjustments);
// Apply offset
//
if (null != paymentDaysOffset)
{
return(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustedPaymentDate, paymentDatesBusinessDayAdjustments, paymentDaysOffset));
}
return(adjustedPaymentDate);
}
case PayRelativeToEnum.CalculationPeriodEndDate:
{
// To get the calculation period end date - obtain a reference to LAST calculation period in the payment period.
//
CalculationPeriod lastCalculatinPeriodInPaymentPeriod = calculationPeriodsInPamentPeriod[calculationPeriodsInPamentPeriod.Count - 1];
BusinessDayAdjustments paymentDatesAdjustments = paymentDates.paymentDatesAdjustments;
// Adjust using paymentDatesAdjustments...
//
DateTime adjustedPaymentDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, lastCalculatinPeriodInPaymentPeriod.unadjustedEndDate, paymentDatesAdjustments);
// Apply offset (if present)
//
return(null != paymentDaysOffset?AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustedPaymentDate, paymentDatesBusinessDayAdjustments, paymentDaysOffset) : adjustedPaymentDate);
}
case PayRelativeToEnum.ResetDate:
{
throw new NotImplementedException("payRelativeTo to ResetDate");
}
default:
{
throw new NotImplementedException("payRelativeTo");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="swaptionFpML"> </param>
/// <param name="basePartyReference"></param>
protected SwaptionPricer(ILogger logger, ICoreCache cache,
String nameSpace, Swaption swaptionFpML, string basePartyReference)
{
ProductType = ProductTypeSimpleEnum.InterestRateSwaption;
if (swaptionFpML == null)
{
return;
}
BuyerPartyReference = swaptionFpML.buyerPartyReference.href;
SellerPartyReference = swaptionFpML.sellerPartyReference.href;
IsBasePartyBuyer = basePartyReference == BuyerPartyReference;
PaymentCurrencies = new List <string>();
var exercise = swaptionFpML.Item as EuropeanExercise;
if (exercise != null)
{
ExerciseType = ExerciseType.European;
Exercise = exercise;
var exerciseDate = AdjustedDateHelper.ToAdjustedDate(cache, null, exercise.expirationDate, nameSpace);
ExerciseDates = new[] { exerciseDate };//TODO Only does adjustabledate exercise.
}
var item = swaptionFpML.exerciseProcedure?.Item as AutomaticExercise;
if (item != null)
{
AutomaticExcercise = true;
}
if (swaptionFpML.premium != null)
{
PremiumPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, swaptionFpML.premium, null);
var paymentAmounts = new List <Decimal>();
var paymentDates = new List <DateTime>();
foreach (var premium in PremiumPayments)
{
paymentAmounts.Add(premium.PaymentAmount.amount);
paymentDates.Add(premium.PaymentDate);
//Add the currencies for the trade pricer.
if (!PaymentCurrencies.Contains(premium.PaymentAmount.currency.Value))
{
PaymentCurrencies.Add(premium.PaymentAmount.currency.Value);
}
}
PremiumPaymentAmounts = paymentAmounts.ToArray();
PremiumPaymentDates = paymentDates.ToArray();
}
var isCashSettled = swaptionFpML.Item1 as CashSettlement;
if (isCashSettled != null)
{
IsCashSettled = true;//TODO extend to the type of calculation.
}
}
public List <DateTime> BuildDates(ILogger logger, ICoreCache cache, String nameSpace, BillSwapPricerDatesRange billSwapPricerDatesRange, IBusinessCalendar paymentCalendar)
{
CalculationPeriodFrequency frequency = CalculationPeriodFrequencyHelper.Parse(billSwapPricerDatesRange.RollFrequency, billSwapPricerDatesRange.RollConvention);
StubPeriodTypeEnum? initialStub = null;
if (!String.IsNullOrEmpty(billSwapPricerDatesRange.InitialStubPeriod))
{
initialStub = EnumHelper.Parse <StubPeriodTypeEnum>(billSwapPricerDatesRange.InitialStubPeriod);
}
StubPeriodTypeEnum?finalStub = null;
if (!String.IsNullOrEmpty(billSwapPricerDatesRange.FinalStubPeriod))
{
finalStub = EnumHelper.Parse <StubPeriodTypeEnum>(billSwapPricerDatesRange.FinalStubPeriod);
}
//BusinessDayAdjustments adjustments = BusinessDayAdjustmentsHelper.Create(BusinessDayConventionEnum.NONE, "");
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustments.businessCenters);//Make sure this builds a valid calendar!
//}
BusinessDayAdjustments calculationPeriodDayAdjustments = BusinessDayAdjustmentsHelper.Create(billSwapPricerDatesRange.BusinessDayConvention, billSwapPricerDatesRange.Calendar);
if (paymentCalendar == null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, calculationPeriodDayAdjustments.businessCenters, nameSpace);
}
CalculationPeriodsPrincipalExchangesAndStubs result = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods(
billSwapPricerDatesRange.StartDate,
billSwapPricerDatesRange.EndDate,
billSwapPricerDatesRange.FirstRegularPeriodStartDate,
frequency,
calculationPeriodDayAdjustments,
initialStub,
finalStub,
paymentCalendar
);
foreach (CalculationPeriod regularCalculationPeriod in result.GetRegularAndStubPeriods())
{
// Adjust both startDate & endDate of period
//
CalculationPeriodHelper.SetAdjustedDates(regularCalculationPeriod,
AdjustedDateHelper.ToAdjustedDate(paymentCalendar, regularCalculationPeriod.unadjustedStartDate, calculationPeriodDayAdjustments),
AdjustedDateHelper.ToAdjustedDate(paymentCalendar, regularCalculationPeriod.unadjustedEndDate, calculationPeriodDayAdjustments));
}
var listResult = result.GetRegularAndStubPeriods().Select(regularCalculationPeriod => regularCalculationPeriod.adjustedStartDate).ToList();
listResult.Add(result.GetRegularAndStubPeriods()[result.GetRegularAndStubPeriods().Count - 1].adjustedEndDate);
return(listResult);
}
private static CalculationPeriod CreateStub(DateTime periodStartDate, DateTime periodEndDate
, BusinessDayAdjustments dateAdjustments, IBusinessCalendar paymentCalendar)
{
var calculationPeriod = new CalculationPeriod();
// Apply ROLL CONVENTION (NOT A BUSINESS DAY CONVENTION!) to unadjusted period start and end dates.
//
CalculationPeriodHelper.SetUnadjustedDates(calculationPeriod, periodStartDate, periodEndDate);
// Set adjusted period dates
//
DateTime adjustedPeriodStartDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, periodStartDate, dateAdjustments);
DateTime adjustedPeriodEndDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, periodEndDate, dateAdjustments);
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod, adjustedPeriodStartDate, adjustedPeriodEndDate);
return(calculationPeriod);
}
public static void UpdatePaymentsAmounts(IBusinessCalendar paymentCalendar,
CapFloor capFloor,
CapFloorLegParametersRange capFloorLeg,
IRateCurve discountCurve,
DateTime valuationDate)
{
foreach (Payment payment in capFloor.additionalPayment)
{
var date = AdjustedDateHelper.GetAdjustedDate(paymentCalendar, payment.paymentDate);
if (date != null)
{
payment.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, (DateTime)date);
payment.discountFactorSpecified = true;
payment.presentValueAmount = MoneyHelper.Mul(payment.paymentAmount, payment.discountFactor);
}
}
}
/// <summary>
/// Gets the adjusted calculation date schedule.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="effectiveDate">The effective date.</param>
/// <param name="intervalToTerminationDate">The interval to termination date.</param>
/// <param name="periodInterval">The period interval.</param>
/// <returns></returns>
/// <param name="businessDayAdjustments">The necessary date adjustment details.</param>
/// <param name="nameSpace">The clients namespace</param>
public List <CalculationPeriod> GetAdjustedCalculationDateSchedule(ICoreCache cache, DateTime effectiveDate,
Period intervalToTerminationDate, Period periodInterval,
BusinessDayAdjustments businessDayAdjustments, string nameSpace)
{
List <CalculationPeriod> adjustedDateScheduleList =
GetUnadjustedCalculationDateSchedule(effectiveDate, intervalToTerminationDate, periodInterval);
foreach (CalculationPeriod period in adjustedDateScheduleList)
{
period.adjustedStartDateSpecified = true;
period.adjustedStartDate =
AdjustedDateHelper.ToAdjustedDate(cache, period.unadjustedStartDate, businessDayAdjustments, nameSpace);
period.adjustedEndDateSpecified = true;
period.adjustedEndDate =
AdjustedDateHelper.ToAdjustedDate(cache, period.unadjustedEndDate, businessDayAdjustments, nameSpace);
}
return(adjustedDateScheduleList);
}
public static void UpdatePaymentsAmounts(ILogger logger, ICoreCache cache,
String nameSpace, Swap swap,
SwapLegParametersRange leg1Parameters,
SwapLegParametersRange leg2Parameters,
IRateCurve leg1DiscountCurve,
IRateCurve leg2DiscountCurve,
DateTime valuationDate, IBusinessCalendar paymentCalendar)
{
foreach (Payment payment in swap.additionalPayment)
{
// choose correct discount curve
//
IRateCurve discountCurve;
if (payment.payerPartyReference.href == leg1Parameters.Payer)
{
discountCurve = leg1DiscountCurve;
}
else if (payment.payerPartyReference.href == leg2Parameters.Payer)
{
discountCurve = leg2DiscountCurve;
}
else
{
throw new NotImplementedException();
}
if (paymentCalendar == null)
{
var containsPaymentDateAdjustments = AdjustableOrAdjustedDateHelper.Contains(payment.paymentDate, ItemsChoiceType.dateAdjustments, out var dateAdjustments);
if (containsPaymentDateAdjustments && dateAdjustments != null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, ((BusinessDayAdjustments)dateAdjustments).
businessCenters, nameSpace);
}
}
var date = AdjustedDateHelper.GetAdjustedDate(paymentCalendar, payment.paymentDate);
if (date == null)
{
continue;
}
payment.discountFactor = (decimal)discountCurve.GetDiscountFactor(valuationDate, (DateTime)date);
payment.discountFactorSpecified = true;
payment.presentValueAmount = MoneyHelper.Mul(payment.paymentAmount, payment.discountFactor);
}
}
/// <summary>
/// Gets the reset date.
/// </summary>
/// <param name="logger"> </param>
/// <param name="cache"> </param>
/// <param name="fixingCalendar"> </param>
/// <param name="fraFpML">The fraFpML.</param>
/// <param name="nameSpace"></param>
/// <returns></returns>
private static DateTime GetResetDate(ILogger logger, ICoreCache cache,
IBusinessCalendar fixingCalendar,
Fra fraFpML, String nameSpace)
{
var effectiveDateId = fraFpML.adjustedEffectiveDate.id;
var fixingdateRef = fraFpML.fixingDateOffset.dateRelativeTo.href;
DateTime resetDate = fraFpML.adjustedEffectiveDate.Value;
if (fixingCalendar == null)
{
fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fraFpML.fixingDateOffset.businessCenters, nameSpace);
}
if (fixingdateRef == effectiveDateId)
{
resetDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, fraFpML.adjustedEffectiveDate.Value, fraFpML.fixingDateOffset);
}
logger.LogInfo("Reset date set.");
return(resetDate);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableCashflow"/> class.
/// </summary>
/// <param name="cashflowId">The identifier.</param>
/// <param name="payerIsBaseParty">The is base party flag.</param>
/// <param name="modelIdentifier">The _model identifier.</param>
/// <param name="amount">The amount.</param>
/// <param name="paymentDate">The payment date.</param>
/// <param name="paymentType">Type of the payment.</param>
/// <param name="cashflowType">Type of the cashflow.</param>
/// <param name="includePaymentDate">if set to <c>true</c> [include payment date].</param>
/// <param name="paymentCalendar">Type paymentCalendar.</param>
protected PriceableCashflow
(
string cashflowId
, string modelIdentifier
, bool payerIsBaseParty
, Money amount
, AdjustableOrAdjustedDate paymentDate
, PaymentType paymentType
, CashflowType cashflowType
, bool includePaymentDate
, IBusinessCalendar paymentCalendar)
{
Multiplier = 1.0m;
var date = AdjustedDateHelper.GetAdjustedDate(paymentCalendar, paymentDate);
if (date != null)
{
PaymentDate = (DateTime)date;
}
var containsPaymentDateAdjustments = AdjustableOrAdjustedDateHelper.Contains(paymentDate, ItemsChoiceType.dateAdjustments, out var dateAdjustments);
if (containsPaymentDateAdjustments && dateAdjustments != null)
{
PaymentDateAdjustments = (BusinessDayAdjustments)dateAdjustments;
}
PayerIsBaseParty = payerIsBaseParty;
Id = cashflowId;
ModelIdentifier = modelIdentifier;
PaymentType = paymentType;
PaymentAmount = amount;
ForecastAmount = amount;
CashflowType = cashflowType;
PaymentDateIncluded = includePaymentDate;
PricingStructureEvolutionType = PricingStructureEvolutionType.ForwardToSpot;
RiskMaturityDate = PaymentDate;
DiscountCurveName = CurveNameHelpers.GetDiscountCurveName(amount.currency.Value, true);
if (!PaymentCurrencies.Contains(amount.currency.Value))
{
PaymentCurrencies.Add(amount.currency.Value);
}
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="swaptionFpML"> </param>
/// <param name="basePartyReference"></param>
/// <param name="forecastRateInterpolation"></param>
protected SwaptionPricer(ILogger logger, ICoreCache cache,
String nameSpace, Swaption swaptionFpML, string basePartyReference, Boolean forecastRateInterpolation)
{
ProductType = ProductTypeSimpleEnum.InterestRateSwaption;
if (swaptionFpML == null)
{
return;
}
BuyerPartyReference = swaptionFpML.buyerPartyReference.href;
SellerPartyReference = swaptionFpML.sellerPartyReference.href;
IsBasePartyBuyer = basePartyReference == BuyerPartyReference;
if (swaptionFpML.Item is EuropeanExercise exercise)
{
ExerciseType = ExerciseType.European;
Exercise = exercise;
var exerciseDate = AdjustedDateHelper.ToAdjustedDate(cache, null, exercise.expirationDate, nameSpace);
ExerciseDates = new[] { exerciseDate };//TODO Only does adjustable date exercise
}
if (swaptionFpML.exerciseProcedure?.Item is AutomaticExercise)
{
AutomaticExcercise = true;
}
if (swaptionFpML.premium != null)
{
PremiumPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, swaptionFpML.premium, null);
}
var paymentAmounts = new List <Decimal>();
var paymentDates = new List <DateTime>();
foreach (var premium in PremiumPayments)
{
paymentAmounts.Add(premium.PaymentAmount.amount);
paymentDates.Add(premium.PaymentDate);
}
PremiumPaymentAmounts = paymentAmounts.ToArray();
PremiumPaymentDates = paymentDates.ToArray();
if (swaptionFpML.Item1 is CashSettlement)
{
IsCashSettled = true;
}
}
/// <summary>
/// Gets the reset date.
/// </summary>
/// <param name="resetRelativeTo">The reset relative to.</param>
/// <returns></returns>
/// <param name="fixingDateRelativeOffset"></param>
private DateTime GetResetDate(ResetRelativeToEnum resetRelativeTo, RelativeDateOffset fixingDateRelativeOffset)
{
var resetDate = AccrualStartDate;
switch (resetRelativeTo)
{
case ResetRelativeToEnum.CalculationPeriodEndDate:
resetDate = AccrualEndDate;
break;
}
var interval = (Period)fixingDateRelativeOffset;
if (fixingDateRelativeOffset != null)
{
var adjustment = BusinessDayAdjustmentsHelper.Create(fixingDateRelativeOffset.businessDayConvention, BusinessCentersHelper.BusinessCentersString(fixingDateRelativeOffset.businessCenters.businessCenter));
resetDate = AdjustedDateHelper.ToAdjustedDate(FixingCalendar, resetDate, adjustment, OffsetHelper.FromInterval(interval, fixingDateRelativeOffset.dayType));
}
return(resetDate);
}
/// <summary>
///
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="baseDateForRelativeOffset"></param>
/// <param name="baseParty"></param>
/// <param name="optionPremia"></param>
/// <param name="fixingCalendar"></param>
/// <param name="paymentCalendar"> </param>
/// <param name="cache"></param>
/// <returns></returns>
public static PriceableFxOptionPremium CreatePriceableFxOptionPremium(ICoreCache cache, String nameSpace,
DateTime?baseDateForRelativeOffset, string baseParty, FxOptionPremium optionPremia,
IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
{
bool payerIsBase = baseParty == optionPremia.payerPartyReference.href;
var multiplier = payerIsBase ? -1.0m : 1.0m;
var settlementDate = AdjustedDateHelper.GetAdjustedDate(cache, nameSpace, fixingCalendar, baseDateForRelativeOffset, optionPremia.paymentDate);
if (settlementDate == null)
{
return(null);
}
var date = new PriceableFxOptionPremium("FxOptionPremiumPayment", optionPremia.payerPartyReference.href,
optionPremia.receiverPartyReference.href, payerIsBase,
MoneyHelper.Mul(optionPremia.paymentAmount, multiplier),
(DateTime)settlementDate, optionPremia.quote,
optionPremia.settlementInformation, paymentCalendar);
return(date);
}
public static CalculationPeriodsPrincipalExchangesAndStubs GenerateCalculationPeriodsPrincipalExchangesAndStubs(
InterestRateStream interestRateStream, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar)
{
CalculationPeriodDates calculationPeriodDates = interestRateStream.calculationPeriodDates;
AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates);
AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(calculationPeriodDates);
AdjustableDate adjustableFirstPeriodDate = adjustableEffectiveDate;
DateTime?firstRegularPeriodStartDate =
XsdClassesFieldResolver.CalculationPeriodDatesGetFirstRegularPeriodStartDate(calculationPeriodDates);
var tempDate = XsdClassesFieldResolver.CalculationPeriodDatesGetFirstPeriodStartDate(calculationPeriodDates);
if (tempDate != null && firstRegularPeriodStartDate != null)
{
adjustableFirstPeriodDate = tempDate;
Frequency frequency = calculationPeriodDates.calculationPeriodFrequency;
var startDate = CalculationPeriodGenerator.AddPeriod((DateTime)firstRegularPeriodStartDate, IntervalHelper.FromFrequency(frequency), -1);
adjustableFirstPeriodDate.unadjustedDate = IdentifiedDateHelper.Create(startDate);
}
DateTime?lastRegularPeriodEndDate =
XsdClassesFieldResolver.CalculationPeriodDatesGetLastRegularPeriodEndDate(calculationPeriodDates);
// This assumes automatic adjustment of calculationperiods.
CalculationPeriodsPrincipalExchangesAndStubs result = CalculationPeriodGenerator.GenerateAdjustedCalculationPeriods(
adjustableFirstPeriodDate.unadjustedDate.Value,
adjustableTerminationDate.unadjustedDate.Value,
firstRegularPeriodStartDate,
lastRegularPeriodEndDate,
calculationPeriodDates.calculationPeriodFrequency,
calculationPeriodDates.calculationPeriodDatesAdjustments,
paymentCalendar);
//Determine whether the reset dates must be calcuated.
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
// Add principle exchanges if this need is defined in parametric representation of the interest rate steam.
//
if (null != interestRateStream.principalExchanges)
{
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableEffectiveDate.dateAdjustments.businessCenters);
//}
// Initial PE
//
if (interestRateStream.principalExchanges.initialExchange)
{
PrincipalExchange initialExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableEffectiveDate));
result.InitialPrincipalExchange = initialExchange;
}
// intermediatory PE
//
if (interestRateStream.principalExchanges.intermediateExchange)
{
// Generate a list of intermediatory PE exchanges
//
Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation);
if (null != notionalSchedule.notionalStepSchedule.step)//there should be steps - otherwise NO interm. exchanges.
{
foreach (DateTime stepDate in ScheduleHelper.GetStepDates(notionalSchedule.notionalStepSchedule))
{
PrincipalExchange intermediatoryExchange = PrincipalExchangeHelper.Create(stepDate);
result.Add(intermediatoryExchange);
}
}
}
// Final PE
// Assume the same calendar is used for the termination date as well!
if (interestRateStream.principalExchanges.finalExchange)
{
PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableTerminationDate));
result.FinalPrincipalExchange = finalExchange;
}
}
//Only does upfront resetRelativeTo start date.
if (interestRateStream.resetDates != null && calculation.Items[0].GetType() == typeof(FloatingRateCalculation))
{
//Get the fixing date convention.
var fixingDateConvention = interestRateStream.resetDates.resetDatesAdjustments;
//if (fixingCalendar == null)
//{
// fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fixingDateConvention.businessCenters);
//}
foreach (var calculationPeriod in result.CalculationPeriods)
{
if (calculationPeriod.adjustedStartDateSpecified)
{
//Set the adjusted fixing date.
var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, calculationPeriod.adjustedStartDate,
fixingDateConvention);
var floatingRateDefinition = new FloatingRateDefinition();
var rateObservation = new RateObservation
{
observedRateSpecified = false,
adjustedFixingDateSpecified = true,
adjustedFixingDate = adjustedFixingDate
};
floatingRateDefinition.rateObservation = new[] { rateObservation };
calculationPeriod.Item1 = floatingRateDefinition;
}
}
//The initial stub period.
if (result.InitialStubCalculationPeriod != null)
{
if (result.InitialStubCalculationPeriod.adjustedStartDateSpecified)
{
//Set the adjusted fixing date.
var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, result.InitialStubCalculationPeriod.adjustedStartDate,
fixingDateConvention);
var floatingRateDefinition = new FloatingRateDefinition();
var rateObservation = new RateObservation
{
observedRateSpecified = false,
adjustedFixingDateSpecified = true,
adjustedFixingDate = adjustedFixingDate
};
floatingRateDefinition.rateObservation = new[] { rateObservation };
result.InitialStubCalculationPeriod.Item1 = floatingRateDefinition;
}
}
//The final stub period
if (result.FinalStubCalculationPeriod != null)
{
if (result.FinalStubCalculationPeriod.adjustedStartDateSpecified)
{
//Set the adjusted fixing date.
var adjustedFixingDate = AdjustedDateHelper.ToAdjustedDate(fixingCalendar, result.FinalStubCalculationPeriod.adjustedStartDate,
fixingDateConvention);
var floatingRateDefinition = new FloatingRateDefinition();
var rateObservation = new RateObservation
{
observedRateSpecified = false,
adjustedFixingDateSpecified = true,
adjustedFixingDate = adjustedFixingDate
};
floatingRateDefinition.rateObservation = new[] { rateObservation };
result.FinalStubCalculationPeriod.Item1 = floatingRateDefinition;
}
}
}
return(result);
}
/// <summary>
/// Don't generate stubs?
/// </summary>
/// <param name="interestRateStream"></param>
/// <param name="rollDates">from #1st roll date to last roll date (last roll dates is effectively the end of the swap)</param>
/// <param name="paymentCalendar"></param>
/// <returns></returns>
public static CalculationPeriodsPrincipalExchangesAndStubs GenerateCalculationPeriodsPrincipalExchangesAndStubsFromRollDates(InterestRateStream interestRateStream,
List <DateTime> rollDates,
IBusinessCalendar paymentCalendar)
{
CalculationPeriodDates calculationPeriodDates = interestRateStream.calculationPeriodDates;
AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(calculationPeriodDates);
var result = new CalculationPeriodsPrincipalExchangesAndStubs();
for (int rollDateIndex = 0; rollDateIndex < rollDates.Count - 1; ++rollDateIndex)
{
DateTime startOfThePeriod = rollDates[rollDateIndex];
DateTime endOfThePeriod = rollDates[rollDateIndex + 1];
var calculationPeriod = new CalculationPeriod();
// Set adjusted period dates
//
CalculationPeriodHelper.SetAdjustedDates(calculationPeriod,
startOfThePeriod,
endOfThePeriod);
result.Add(calculationPeriod);
}
// Add principle exchanges if this need is defined in parametric representation of the interest rate steam.
//
if (null != interestRateStream.principalExchanges)
{
// Initial PE
//
if (interestRateStream.principalExchanges.initialExchange)
{
//if (paymentCalendar == null)
//{
// paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableEffectiveDate.dateAdjustments.businessCenters);
//}
PrincipalExchange initialExchange = PrincipalExchangeHelper.Create(AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableEffectiveDate));
result.InitialPrincipalExchange = initialExchange;
}
// intermediatory PE
//
if (interestRateStream.principalExchanges.intermediateExchange)
{
// Generate a list of intermediatory PE exchanges
//
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation);
if (null != notionalSchedule.notionalStepSchedule.step)//there should be steps - otherwise NO interm. exchanges.
{
foreach (DateTime stepDate in ScheduleHelper.GetStepDates(notionalSchedule.notionalStepSchedule))
{
PrincipalExchange intermediatoryExchange = PrincipalExchangeHelper.Create(stepDate);
result.Add(intermediatoryExchange);
}
}
}
//AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDates_GetTerminationDate(calculationPeriodDates);
DateTime lastRollDate = rollDates[rollDates.Count - 1];
// Final PE
//
if (interestRateStream.principalExchanges.finalExchange)
{
//PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(DateTypesHelper.ToAdjustedDate(adjustableTerminationDate));
PrincipalExchange finalExchange = PrincipalExchangeHelper.Create(lastRollDate);
result.FinalPrincipalExchange = finalExchange;
}
}
return(result);
}
/// <summary>
/// Calculates the specified model data.
/// </summary>
/// <param name="modelData">The model data.</param>
/// <returns></returns>
public override AssetValuation Calculate(IInstrumentControllerData modelData)
{
ModelData = modelData;
AnalyticModelParameters = null;
AnalyticsModel = new FloatingRateCouponAnalytic();
RequiresReset = modelData.ValuationDate > ResetDate;
IsRealised = HasBeenRealised(ModelData.ValuationDate);
//Make sure there are some bucket dates even if not set previously.
if (BucketedDates.Length < 1)
{
UpdateBucketingInterval(ModelData.ValuationDate, PeriodHelper.Parse(CDefaultBucketingInterval));
}
//Add the extra metrics required
var quotes = ModelData.AssetValuation.quote.ToList();
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.BreakEvenRate.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.BreakEvenRate.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.AccrualFactor.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.AccrualFactor.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.FloatingNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.FloatingNPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.NPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.NPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.RiskNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.RiskNPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.LocalCurrencyNPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyExpectedValue.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.LocalCurrencyExpectedValue.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
//Check if risk calc are required.
bool delta1PDH = AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyDelta1PDH.ToString()) != null ||
AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.Delta1PDH.ToString()) != null;
//Check if risk calc are required.
bool delta0PDH = AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyDelta0PDH.ToString()) != null ||
AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.Delta0PDH.ToString()) != null;
ModelData.AssetValuation.quote = quotes.ToArray();
var metrics = ResolveModelMetrics(AnalyticsModel.Metrics);
IFxCurve fxCurve = null;
IRateCurve discountCurve = null;
IRateCurve forecastCurve = null;
//// Determine if DFAM has been requested - if so thats all we evaluate - every other metric is ignored
//if (metrics.Contains(InstrumentMetrics.DiscountFactorAtMaturity))
//{
// metrics.RemoveAll(metricItem => metricItem != InstrumentMetrics.DiscountFactorAtMaturity);
//}
//Set the forrecast rate dates. The ForecastRateInterpolation shhould have been set.
ForwardStartDate = AccrualStartDate;
ForwardEndDate = ForecastRateInterpolation ? AccrualEndDate : AdjustedDateHelper.ToAdjustedDate(FixingCalendar, ForecastRateIndex.indexTenor.Add(ForwardStartDate), AccrualBusinessDayAdjustments);
//var metricsToEvaluate = metrics.ToArray();
if (metrics.Count > 0)
{
YearFractionToCashFlowPayment = GetPaymentYearFraction(ModelData.ValuationDate, PaymentDate);
var reportingCurrency = ModelData.ReportingCurrency == null ? PaymentCurrency.Value : ModelData.ReportingCurrency.Value;
var amount = NotionalAmount.amount;
IRateCouponParameters analyticModelParameters = new RateCouponParameters {
Multiplier = Multiplier,
ValuationDate = modelData.ValuationDate,
PaymentDate = PaymentDate,
Currency = PaymentCurrency.Value,
ReportingCurrency = reportingCurrency,
DiscountType = DiscountType,
IsRealised = IsRealised,
HasReset = RequiresReset,
NotionalAmount = amount,
Spread = Margin,
YearFraction = CouponYearFraction,
CurveYearFraction = YearFractionToCashFlowPayment
};
decimal?discountRate = null;
// Curve Related
if (modelData.MarketEnvironment is ISwapLegEnvironment environment)
{
var streamMarket = environment;
discountCurve = streamMarket.GetDiscountRateCurve();
discountCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
forecastCurve = streamMarket.GetForecastRateCurve();
forecastCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
DiscountCurveName = discountCurve.GetPricingStructureId().UniqueIdentifier;
analyticModelParameters.DiscountCurve = discountCurve;
ForecastCurveName = forecastCurve.GetPricingStructureId().UniqueIdentifier;
analyticModelParameters.ForecastCurve = forecastCurve;
// Bucketed Delta
if (BucketedDates.Length > 1)
{
analyticModelParameters.PeriodAsTimesPerYear = GetPaymentYearFraction(BucketedDates[0],
BucketedDates[1]);
analyticModelParameters.BucketedDiscountFactors = GetBucketedDiscountFactors(discountCurve,
ModelData.
ValuationDate,
BucketedDates);
}
//Check for currency.
if (ModelData.ReportingCurrency != null)
{
if (ModelData.ReportingCurrency.Value != PaymentCurrency.Value)
{
fxCurve = streamMarket.GetReportingCurrencyFxCurve();
fxCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
analyticModelParameters.ReportingCurrencyFxCurve = fxCurve;
}
}
AnalyticModelParameters = analyticModelParameters;
}
else if (modelData.MarketEnvironment.GetType() == typeof(MarketEnvironment))
{
var market = (MarketEnvironment)modelData.MarketEnvironment;
discountCurve = (IRateCurve)market.SearchForPricingStructureType(DiscountCurveName);
discountCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
forecastCurve = (IRateCurve)market.SearchForPricingStructureType(ForecastCurveName);
forecastCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
analyticModelParameters.DiscountCurve = discountCurve;
analyticModelParameters.ForecastCurve = forecastCurve;
// Bucketed Delta
if (BucketedDates.Length > 1)
{
analyticModelParameters.PeriodAsTimesPerYear = GetPaymentYearFraction(BucketedDates[0],
BucketedDates[1]);
analyticModelParameters.BucketedDiscountFactors = GetBucketedDiscountFactors(discountCurve,
ModelData.
ValuationDate,
BucketedDates);
}
if (delta1PDH)
{
var riskMarket = market.SearchForPerturbedPricingStructures(DiscountCurveName, "delta1PDH");
analyticModelParameters.Delta1PDHCurves = riskMarket;
analyticModelParameters.Delta1PDHPerturbation = 10;
}
if (delta0PDH)
{
var riskMarket = market.SearchForPerturbedPricingStructures(ForecastCurveName, "delta0PDH");
analyticModelParameters.Delta0PDHCurves = riskMarket;
analyticModelParameters.Delta0PDHPerturbation = 10;
}
//Check for currency.
if (ModelData.ReportingCurrency != null)
{
if (ModelData.ReportingCurrency.Value != PaymentCurrency.Value)
{
string curveName = MarketEnvironmentHelper.ResolveFxCurveNames(PaymentCurrency.Value, modelData.ReportingCurrency.Value);
fxCurve = (IFxCurve)market.SearchForPricingStructureType(curveName);
fxCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
analyticModelParameters.ReportingCurrencyFxCurve = fxCurve;
}
}
AnalyticModelParameters = analyticModelParameters;
}
//Set the base rate. Default is zero
if (AnalyticModelParameters != null)
{
AnalyticModelParameters.BaseRate = BaseRate;
}
if (UseObservedRate)
{
AnalyticsModel = new FixedRateCouponAnalytic(ModelData.ValuationDate, AccrualStartDate, AccrualEndDate, PaymentDate, Rate,
analyticModelParameters.YearFraction, DiscountType, fxCurve, discountCurve, forecastCurve);
if (Rate != null)
{
analyticModelParameters.Rate = (decimal)Rate;
}
}
else
{
if (Rate != null)
{
discountRate = Rate;
}
if (DiscountRate != null)
{
discountRate = DiscountRate;
}
AnalyticsModel = new FloatingRateCouponAnalytic(ModelData.ValuationDate, AccrualStartDate,
AccrualEndDate, PaymentDate, discountRate,
analyticModelParameters.YearFraction,
DiscountType, fxCurve, discountCurve,
forecastCurve);
}
CalculationResults = AnalyticsModel.Calculate <IRateInstrumentResults, RateInstrumentResults>(AnalyticModelParameters, metrics.ToArray());
CalculationPerfomedIndicator = true;
PaymentDiscountFactor = ((FixedRateCouponAnalytic)AnalyticsModel).PaymentDiscountFactor;
if (!UseObservedRate)
{
Rate = CalculationResults.BreakEvenRate;
}
ForecastAmount = MoneyHelper.GetAmount(CalculationResults.LocalCurrencyExpectedValue, PaymentAmount.currency);
NPV = MoneyHelper.GetAmount(CalculationResults.LocalCurrencyNPV, PaymentAmount.currency);
}
AssetValuation valuation = GetValue(CalculationResults, modelData.ValuationDate);
valuation.id = Id;
return(valuation);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="paymentCalendar"> </param>
/// <param name="capFloorFpML"></param>
/// <param name="basePartyReference"></param>
/// <param name="forecastRateInterpolation"></param>
/// <param name="nameSpace"></param>
/// <param name="fixingCalendar"> </param>
public CapFloorPricer(ILogger logger, ICoreCache cache, String nameSpace,
IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar,
CapFloor capFloorFpML, string basePartyReference, Boolean forecastRateInterpolation)
{
if (capFloorFpML == null)
{
return;
}
//AnalyticsModel = new SimpleIRSwapInstrumentAnalytic();
BusinessCentersResolver.ResolveBusinessCenters(capFloorFpML);
ForecastRateInterpolation = forecastRateInterpolation;
//We make the assumption that the termination date is the same for all legs..
AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(capFloorFpML.capFloorStream.calculationPeriodDates);
if (paymentCalendar == null)
{
paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableTerminationDate.dateAdjustments.businessCenters, nameSpace);
}
RiskMaturityDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableTerminationDate);
ProductType = ProductTypeSimpleEnum.CapFloor;
PaymentCurrencies = new List <string>();
//Resolve the payer
if (capFloorFpML.capFloorStream == null)
{
return;
}
var calculation = capFloorFpML.capFloorStream.calculationPeriodAmount.Item as Calculation;
var floatingRatecalculation = calculation?.Items[0] as FloatingRateCalculation;
if (floatingRatecalculation == null)
{
return;
}
if (floatingRatecalculation.capRateSchedule != null)
{
var schedule = floatingRatecalculation.capRateSchedule[0];
var buyerPartyReference = schedule.buyer.Value;
if (buyerPartyReference == PayerReceiverEnum.Receiver)
{
BuyerPartyReference = capFloorFpML.capFloorStream.receiverPartyReference.href;
SellerPartyReference = capFloorFpML.capFloorStream.payerPartyReference.href;
}
else
{
BuyerPartyReference = capFloorFpML.capFloorStream.payerPartyReference.href;
SellerPartyReference = capFloorFpML.capFloorStream.receiverPartyReference.href;
}
}
if (floatingRatecalculation.capRateSchedule == null && floatingRatecalculation.floorRateSchedule != null)
{
var schedule = floatingRatecalculation.floorRateSchedule[0];
var buyerPartyReference = schedule.buyer.Value;
if (buyerPartyReference == PayerReceiverEnum.Receiver)
{
BuyerPartyReference = capFloorFpML.capFloorStream.receiverPartyReference.href;
SellerPartyReference = capFloorFpML.capFloorStream.payerPartyReference.href;
}
else
{
BuyerPartyReference = capFloorFpML.capFloorStream.payerPartyReference.href;
SellerPartyReference = capFloorFpML.capFloorStream.receiverPartyReference.href;
}
}
BasePartyBuyer = basePartyReference == BuyerPartyReference;//TODO add in the calendar functionality.
//Set the id of the first stream. THe generator requires the flag: BasePartyPayer.
var capFloorLeg = new PriceableCapFloorStream(logger, cache, nameSpace, !BasePartyBuyer, capFloorFpML.capFloorStream, ForecastRateInterpolation, fixingCalendar, paymentCalendar);
Legs.Add(capFloorLeg);
//Add the currencies for the trade pricer.
if (!PaymentCurrencies.Contains(capFloorLeg.Currency.Value))
{
PaymentCurrencies.Add(capFloorLeg.Currency.Value);
}
if (capFloorFpML.additionalPayment != null)
{
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, capFloorFpML.additionalPayment, null);
foreach (var payment in capFloorFpML.additionalPayment)
{
if (!PaymentCurrencies.Contains(payment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(payment.paymentAmount.currency.Value);
}
}
}
}
protected SwapPricer(ILogger logger, ICoreCache cache, String nameSpace,
List <Pair <IBusinessCalendar, IBusinessCalendar> > legCalendars,
Swap swapFpML, string basePartyReference,
ProductTypeSimpleEnum productType, Boolean forecastRateInterpolation)
{
Multiplier = 1.0m;
if (swapFpML == null)
{
return;
}
BusinessCentersResolver.ResolveBusinessCenters(swapFpML);
ForecastRateInterpolation = forecastRateInterpolation;
//Get the effective date
AdjustableDate adjustableEffectiveDate = XsdClassesFieldResolver.CalculationPeriodDatesGetEffectiveDate(swapFpML.swapStream[0].calculationPeriodDates);
EffectiveDate = adjustableEffectiveDate.unadjustedDate.Value;
//We make the assumption that the termination date is the same for all legs.
AdjustableDate adjustableTerminationDate = XsdClassesFieldResolver.CalculationPeriodDatesGetTerminationDate(swapFpML.swapStream[0].calculationPeriodDates);
var paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableTerminationDate.dateAdjustments.businessCenters, nameSpace);
TerminationDate = AdjustedDateHelper.ToAdjustedDate(paymentCalendar, adjustableTerminationDate);
RiskMaturityDate = TerminationDate;
//EffectiveDate is not set;
ProductType = productType;
PaymentCurrencies = new List <string>();
//Resolve the payer
var legs = swapFpML.swapStream.Length;
if (legs == 0)
{
return;
}
var flag = false;
var index = 0;
if (legCalendars != null && legCalendars.Count == legs)
{
flag = true;
}
foreach (var swapStream in swapFpML.swapStream)
{
bool payerIsBase = basePartyReference == swapStream.payerPartyReference.href;//TODO add in the calendar functionality.
//Set the id of the first stream.
PriceableInterestRateStream leg = flag ? new PriceableInterestRateStream(logger, cache, nameSpace, payerIsBase, swapStream, ForecastRateInterpolation, legCalendars[index].First, legCalendars[index].Second)
: new PriceableInterestRateStream(logger, cache, nameSpace, payerIsBase, swapStream, ForecastRateInterpolation, null, null);
Legs.Add(leg);
//Add the currencies for the trade pricer.
if (!PaymentCurrencies.Contains(leg.Currency.Value))
{
PaymentCurrencies.Add(leg.Currency.Value);
}
index++;
}
if (swapFpML.additionalPayment != null)
{
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, swapFpML.additionalPayment, null);
foreach (var payment in swapFpML.additionalPayment)
{
if (!PaymentCurrencies.Contains(payment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(payment.paymentAmount.currency.Value);
}
}
}
}
