/// <summary>
/// Calculates the specified model data.
/// </summary>
/// <param name="modelData">The model data.</param>
/// <returns></returns>
public override BasicAssetValuation Calculate(IAssetControllerData modelData)
{
ModelData = modelData;
if (AnalyticsModel == null)
{
AnalyticsModel = new RateAssetAnalytic();
//DependencyCreator.Resolve<IModelAnalytic<ISimpleAssetParameters, RateMetrics>>(_modelIdentifier);
}
var metrics = MetricsHelper.GetMetricsToEvaluate(Metrics, AnalyticsModel.Metrics);
// Determine if DFAM has been requested - if so thats all we evaluate - every other metric is ignored
//
var bEvalDiscountFactorAtMaturity = false;
if (metrics.Contains(RateMetrics.DiscountFactorAtMaturity))
{
bEvalDiscountFactorAtMaturity = true;
// Remove all metrics except DFAM
//
metrics.RemoveAll(metricItem => metricItem != RateMetrics.DiscountFactorAtMaturity);
}
ISimpleRateAssetParameters analyticModelParameters = new RateAssetParameters {
YearFraction = YearFraction
};
CalculationResults = new RateAssetResults();
var metricsToEvaluate = metrics.ToArray();
var marketEnvironment = modelData.MarketEnvironment;
IRateCurve curve = null;
//1. instantiate curve
if (marketEnvironment.GetType() == typeof(SimpleMarketEnvironment))
{
curve = (IRateCurve)((ISimpleMarketEnvironment)marketEnvironment).GetPricingStructure();
CurveName = curve.GetPricingStructureId().UniqueIdentifier;
}
if (marketEnvironment.GetType() == typeof(SimpleRateMarketEnvironment))
{
curve = ((ISimpleRateMarketEnvironment)marketEnvironment).GetRateCurve();
CurveName = curve.GetPricingStructureId().UniqueIdentifier;
}
if (marketEnvironment.GetType() == typeof(SwapLegEnvironment))
{
curve = ((ISwapLegEnvironment)marketEnvironment).GetDiscountRateCurve();
CurveName = curve.GetPricingStructureId().UniqueIdentifier;
}
if (marketEnvironment.GetType() == typeof(MarketEnvironment))
{
curve = (IRateCurve)modelData.MarketEnvironment.GetPricingStructure(CurveName);
}
//2. get start df = curve.getvalue(this._adjustedStartDate);
//
analyticModelParameters.StartDiscountFactor = GetDiscountFactor(curve, AdjustedStartDate, modelData.ValuationDate);
//3. Get the Rate
//
if (FixedRate != null)
{
analyticModelParameters.Rate = MarketQuoteHelper.NormalisePriceUnits(FixedRate, "DecimalRate").value;
}
if (bEvalDiscountFactorAtMaturity)
{
//4. Set the anaytic input parameters and Calculate the respective metrics
//
CalculationResults = AnalyticsModel.Calculate <IRateAssetResults, RateAssetResults>(analyticModelParameters, metricsToEvaluate);
EndDiscountFactor = CalculationResults.DiscountFactorAtMaturity;
}
else
{
analyticModelParameters.NotionalAmount = Notional;
//3. Get the end discount factor
//
EndDiscountFactor = GetDiscountFactor(curve, GetRiskMaturityDate(), modelData.ValuationDate);
analyticModelParameters.EndDiscountFactor = EndDiscountFactor;
analyticModelParameters.PaymentDiscountFactor = analyticModelParameters.EndDiscountFactor;
//4. Set the anaytic input parameters and Calculate the respective metrics
//
CalculationResults = AnalyticsModel.Calculate <IRateAssetResults, RateAssetResults>(analyticModelParameters, metricsToEvaluate);
}
return(GetValue(CalculationResults));
}
public override AssetValuation Calculate(IInstrumentControllerData modelData)
{
ModelData = modelData;
AnalyticModelParameters = null;
CalculationResults = null;
UpdateBucketingInterval(ModelData.ValuationDate, PeriodHelper.Parse(CDefaultBucketingInterval));
// 1. First derive the analytics to be evaluated via the stream controller model
// NOTE: These take precedence of the child model metrics
if (AnalyticsModel == null)
{
AnalyticsModel = new CapFloorStreamAnalytic();
}
var streamControllerMetrics = ResolveModelMetrics(AnalyticsModel.Metrics);
AssetValuation streamValuation;
// 2. Now evaluate only the child specific metrics (if any)
foreach (var coupon in Coupons)
{
coupon.PricingStructureEvolutionType = PricingStructureEvolutionType;
coupon.BucketedDates = BucketedDates;
coupon.Multiplier = 1.0m;//TODO this will have to be fixed eventually.
}
var childControllers = new List <InstrumentControllerBase>(Coupons.ToArray());
//Add the extra metrics required
var quotes = ModelData.AssetValuation.quote.ToList();
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.AccrualFactor.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.AccrualFactor.ToString(), "DecimalValue");
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.FloatingNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.FloatingNPV.ToString(), "DecimalValue");
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.NPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.NPV.ToString(), "DecimalValue");
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.LocalCurrencyNPV.ToString(), "DecimalValue");
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.LocalCurrencyExpectedValue.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.LocalCurrencyExpectedValue.ToString(), "DecimalValue");
quotes.Add(quote);
}
ModelData.AssetValuation.quote = quotes.ToArray();
var childValuations = EvaluateChildMetrics(childControllers, modelData, Metrics);
var couponValuation = AssetValuationHelper.AggregateMetrics(childValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
var childControllerValuations = new List <AssetValuation> {
couponValuation
};
if (Exchanges != null && Exchanges.Count > 0)
{
foreach (var exchange in Exchanges)
{
exchange.PricingStructureEvolutionType = PricingStructureEvolutionType;
exchange.BucketedDates = BucketedDates;
exchange.Multiplier = 1.0m;//TODO this will have to be fixed eventually.
}
// Roll-Up and merge child valuations into parent Valuation
var childPrincipalControllers = new List <InstrumentControllerBase>(Exchanges.ToArray());
var childPrincipalValuations = EvaluateChildMetrics(childPrincipalControllers, modelData, Metrics);
var principalValuation = AssetValuationHelper.AggregateMetrics(childPrincipalValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
childControllerValuations.Add(principalValuation);
}
// Child metrics have now been calculated so we can now evaluate the stream model metrics
if (streamControllerMetrics.Count > 0)
{
var reportingCurrency = ModelData.ReportingCurrency == null
? Currency.Value
: ModelData.ReportingCurrency.Value;
ICapFloorStreamParameters analyticModelParameters = new CapFloorStreamParameters
{
Multiplier = 1.0m,
Currency = Currency.Value,
ReportingCurrency = reportingCurrency,
AccrualFactor = AggregateMetric(InstrumentMetrics.AccrualFactor, childControllerValuations),
FloatingNPV = AggregateMetric(InstrumentMetrics.FloatingNPV, childControllerValuations),
NPV = AggregateMetric(InstrumentMetrics.NPV, childControllerValuations) //,
};
CalculationResults = AnalyticsModel.Calculate <ICapFloorStreamInstrumentResults, CapFloorStreamInstrumentResults>(analyticModelParameters, streamControllerMetrics.ToArray());
// Now merge back into the overall stream valuation
var streamControllerValuation = GetValue(CalculationResults, modelData.ValuationDate);
streamValuation = AssetValuationHelper.UpdateValuation(streamControllerValuation,
childControllerValuations, ConvertMetrics(streamControllerMetrics), new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
}
else
{
streamValuation = AssetValuationHelper.AggregateMetrics(childControllerValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
}
CalculationPerformedIndicator = true;
streamValuation.id = Id;
return(streamValuation);
}
/// <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;
CalculationResults = null;
UpdateBucketingInterval(ModelData.ValuationDate, PeriodHelper.Parse(CDefaultBucketingInterval));
// 1. First derive the analytics to be evaluated via the stream controller model
// NOTE: These take precedence of the child model metrics
if (AnalyticsModel == null)
{
AnalyticsModel = new CapFloorInstrumentAnalytic();
}
var swapControllerMetrics = ResolveModelMetrics(AnalyticsModel.Metrics);
AssetValuation swapValuation;
//Sets the evolution type for calculations.
CapFloorLeg.PricingStructureEvolutionType = PricingStructureEvolutionType;
CapFloorLeg.BucketedDates = BucketedDates;
CapFloorLeg.Multiplier = Multiplier;
if (AdditionalPayments != null)
{
foreach (var payment in AdditionalPayments)
{
payment.PricingStructureEvolutionType = PricingStructureEvolutionType;
payment.BucketedDates = BucketedDates;
payment.Multiplier = Multiplier;
}
}
//The assetValuation list.
var childValuations = new List <AssetValuation> {
CapFloorLeg.Calculate(modelData)
};
// 2. Now evaluate only the child specific metrics (if any)
if (GetAdditionalPayments() != null)
{
var paymentControllers = new List <InstrumentControllerBase>(GetAdditionalPayments());
childValuations.AddRange(paymentControllers.Select(payment => payment.Calculate(modelData)));
}
var childControllerValuations = AssetValuationHelper.AggregateMetrics(childValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
childControllerValuations.id = Id + ".CapFloorStreams";
// Child metrics have now been calculated so we can now evaluate the stream model metrics
if (swapControllerMetrics.Count > 0)
{
//Generate the vectors
var streamAccrualFactor = AssetValuationHelper.GetQuotationByMeasureType(childValuations[0], InstrumentMetrics.AccrualFactor.ToString());
var streamFloatingNPV = AssetValuationHelper.GetQuotationByMeasureType(childValuations[0], InstrumentMetrics.FloatingNPV.ToString());
var streamNPV = AssetValuationHelper.GetQuotationByMeasureType(childValuations[0], InstrumentMetrics.NPV.ToString());
IIRSwapInstrumentParameters analyticModelParameters = new SwapInstrumentParameters
{
AccrualFactor = streamAccrualFactor.value,
FloatingNPV = streamFloatingNPV.value,
NPV = streamNPV.value
//, MarketQuote = MarketQuote.
};
AnalyticModelParameters = analyticModelParameters;
CalculationResults = AnalyticsModel.Calculate <IIRSwapInstrumentResults, SwapInstrumentResults>(analyticModelParameters, swapControllerMetrics.ToArray());
// Now merge back into the overall stream valuation
var swapControllerValuation = GetValue(CalculationResults, modelData.ValuationDate);
swapValuation = AssetValuationHelper.UpdateValuation(swapControllerValuation,
childControllerValuations, ConvertMetrics(swapControllerMetrics), new List <string>(Metrics));
}
else
{
swapValuation = childControllerValuations;
}
CalculationPerformedIndicator = true;
swapValuation.id = Id;
return(swapValuation);
}
/// <summary>
/// Calculates the specified metric for the fast bootstrapper.
/// </summary>
/// <param name="discountCurve">The discount curve.</param>
/// <param name="forecastCurve">The forecast curve</param>
/// <param name="curveToPerturb">The curve to perturb: the discount curve, the forecast curve or both.</param>
/// <returns></returns>
public IDictionary <string, Decimal> CalculatePDH(CurveBase discountCurve, CurveBase forecastCurve, CurvePerturbation curveToPerturb)
{
if (AnalyticsModel == null)
{
switch (ModelIdentifier)
{
case "SwapAsset":
AnalyticsModel = new SwapAssetAnalytic();
break;
case "DiscountSwapAsset":
AnalyticsModel = new DiscountSwapAssetAnalytic();
break;
}
}
var result = new Dictionary <string, Decimal>();
if (discountCurve != null && forecastCurve != null)
{
ISwapAssetParameters analyticModelParameters = new IRSwapAssetParameters
{
NotionalAmount = Notional,
//2. Get the discount factors
DiscountFactors =
GetDiscountFactors(discountCurve,
AdjustedPeriodDates.ToArray(),
BaseDate),
//3. Get the respective year fractions
YearFractions = YearFractions,
Weightings = Weightings,
Rate =
MarketQuoteHelper.NormalisePriceUnits(
FixedRate, "DecimalRate").value,
FloatingLegDiscountFactors =
GetDiscountFactors(discountCurve,
FloatingLegAdjustedPeriodDates.ToArray(),
BaseDate),
FloatingLegForecastDiscountFactors =
GetDiscountFactors(forecastCurve, FloatingLegAdjustedPeriodDates.ToArray(), BaseDate),
FloatingLegYearFractions = FloatingLegYearFractions,
FloatingLegWeightings = FloatingLegWeightings,
FloatingLegSpread =
MarketQuoteHelper.NormalisePriceUnits(
FloatingLegSpread, "DecimalRate").value
};
if (ForwardRates != null)
{
analyticModelParameters.FloatingLegForwardRates = ForwardRates;
}
//4. Set the analytic input parameters and Calculate the respective metrics
//
if (AnalyticsModel != null)
{
var analyticResults = AnalyticsModel.Calculate <IRateAssetResults, RateAssetResults>(analyticModelParameters, new[] { RateMetrics.NPV });
AnalyticResults = analyticResults;
analyticModelParameters.BaseNPV = analyticResults.NPV;
//Now loop through the risk curves.
if (curveToPerturb == CurvePerturbation.DiscountCurve)
{
var riskCurves = discountCurve.CreateCurveRiskSet(1);
foreach (var curve in riskCurves)
{
var perturbedAsset = curve.GetPricingStructureId().Properties.GetValue <string>("PerturbedAsset");
analyticResults = RiskCalculationHelper((IRateCurve)curve, analyticModelParameters);
result.Add("DiscountCurve:" + perturbedAsset, analyticResults.NPVChange);
}
}
if (curveToPerturb == CurvePerturbation.ForecastCurve)
{
var riskCurves = forecastCurve.CreateCurveRiskSet(1);
foreach (var curve in riskCurves)
{
var perturbedAsset = curve.GetPricingStructureId().Properties.GetValue <string>("PerturbedAsset");
analyticResults = ForecastRiskCalculationHelper((IRateCurve)curve, analyticModelParameters);
result.Add("ForecastCurve:" + perturbedAsset, analyticResults.NPVChange);
}
}
if (curveToPerturb == CurvePerturbation.Both)
{
var riskCurves1 = discountCurve.CreateCurveRiskSet(1);
foreach (var curve in riskCurves1)
{
var perturbedAsset = curve.GetPricingStructureId().Properties.GetValue <string>("PerturbedAsset");
analyticResults = RiskCalculationHelper((IRateCurve)curve, analyticModelParameters);
result.Add("DiscountCurve:" + perturbedAsset, analyticResults.NPVChange);
}
var riskCurves2 = forecastCurve.CreateCurveRiskSet(1);
foreach (var curve in riskCurves2)
{
var perturbedAsset = curve.GetPricingStructureId().Properties.GetValue <string>("PerturbedAsset");
analyticResults = ForecastRiskCalculationHelper((IRateCurve)curve, analyticModelParameters);
result.Add("ForecastCurve:" + perturbedAsset, analyticResults.NPVChange);
}
}
}
}
return(result);
}
public override AssetValuation Calculate(IInstrumentControllerData modelData)
{
ModelData = modelData;
AnalyticModelParameters = null;
CalculationResults = null;
UpdateBucketingInterval(ModelData.ValuationDate, PeriodHelper.Parse(CDefaultBucketingInterval));
// 1. First derive the analytics to be evaluated via the stream controller model
// NOTE: These take precedence of the child model metrics
if (AnalyticsModel == null)
{
AnalyticsModel = new StructuredStreamAnalytic();
}
var streamControllerMetrics = ResolveModelMetrics(AnalyticsModel.Metrics);
AssetValuation streamValuation;
// 2. Now evaluate only the child specific metrics (if any)
foreach (var coupon in Coupons)
{
coupon.PricingStructureEvolutionType = PricingStructureEvolutionType;
coupon.BucketedDates = BucketedDates;
coupon.Multiplier = Multiplier;
}
var childControllers = new List <InstrumentControllerBase>(Coupons.ToArray());
//Now the stream analytics can be completed.
var childValuations = EvaluateChildMetrics(childControllers, modelData, Metrics);
var couponValuation = AssetValuationHelper.AggregateMetrics(childValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
var childControllerValuations = new List <AssetValuation> {
couponValuation
};
if (Exchanges != null && Exchanges.Count > 0)
{
foreach (var exchange in Exchanges)
{
exchange.PricingStructureEvolutionType = PricingStructureEvolutionType;
exchange.BucketedDates = BucketedDates;
exchange.Multiplier = Multiplier;
}
// Roll-Up and merge child valuations into parent Valuation
var childPrincipalControllers = new List <InstrumentControllerBase>(Exchanges.ToArray());
var childPrincipalValuations = EvaluateChildMetrics(childPrincipalControllers, modelData, Metrics);
var principalValuation = AssetValuationHelper.AggregateMetrics(childPrincipalValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
childControllerValuations.Add(principalValuation);
}
// Child metrics have now been calculated so we can now evaluate the stream model metrics
if (streamControllerMetrics.Count > 0)
{
var reportingCurrency = ModelData.ReportingCurrency == null ? Currency.Value : ModelData.ReportingCurrency.Value;
var notionals = GetCouponNotionals();
var accrualFactors = GetCouponAccrualFactors();
var discountFactors = GetPaymentDiscountFactors();
var floatingNPV = AggregateMetric(InstrumentMetrics.FloatingNPV, childControllerValuations);
var accrualFactor = AggregateMetric(InstrumentMetrics.AccrualFactor, childControllerValuations);
//TODO need to set the notional amount and the weighting. Also amortisation??
IStructuredStreamParameters analyticModelParameters = new StructuredStreamParameters
{
Multiplier = Multiplier,
IsDiscounted = IsDiscounted,
CouponNotionals = notionals,
Currency = Currency.Value,
ReportingCurrency = reportingCurrency,
AccrualFactor = accrualFactor,
FloatingNPV = floatingNPV,
NPV = AggregateMetric(InstrumentMetrics.NPV, childControllerValuations),
CouponYearFractions = accrualFactors,
PaymentDiscountFactors = discountFactors,
TargetNPV = floatingNPV
};
CalculationResults = AnalyticsModel.Calculate <IStreamInstrumentResults, StreamInstrumentResults>(analyticModelParameters, streamControllerMetrics.ToArray());
// Now merge back into the overall stream valuation
var streamControllerValuation = GetValue(CalculationResults, modelData.ValuationDate);
streamValuation = AssetValuationHelper.UpdateValuation(streamControllerValuation,
childControllerValuations, ConvertMetrics(streamControllerMetrics), new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
AnalyticModelParameters = analyticModelParameters;
}
else
{
streamValuation = AssetValuationHelper.AggregateMetrics(childControllerValuations, new List <string>(Metrics), PaymentCurrencies);// modelData.ValuationDate);
}
CalculationPerformedIndicator = true;
streamValuation.id = Id;
return(streamValuation);
}
/// <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 FxOptionAnalytic();
CalculationResults = null;
YearFractionToCashFlowPayment = Convert.ToDecimal(CDefaultDayCounter.YearFraction(ModelData.ValuationDate, PaymentDate));
//Make sure there are some bucket dates even if not set previously.
if (BucketedDates.Length < 1)
{
UpdateBucketingInterval(ModelData.ValuationDate, PeriodHelper.Parse(CDefaultBucketingInterval));
}
IsRealised = HasBeenRealised(ModelData.ValuationDate);
//Add the extra metrics required
var quotes = ModelData.AssetValuation.quote.ToList();
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, FloatingCashflowMetrics.NPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, FloatingCashflowMetrics.LocalCurrencyNPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, FloatingCashflowMetrics.LocalCurrencyNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, FloatingCashflowMetrics.LocalCurrencyNPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, InstrumentMetrics.RiskNPV.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, InstrumentMetrics.NPV.ToString(), "DecimalValue", ModelData.ValuationDate);
quotes.Add(quote);
}
if (AssetValuationHelper.GetQuotationByMeasureType(ModelData.AssetValuation, FloatingCashflowMetrics.LocalCurrencyExpectedValue.ToString()) == null)
{
var quote = QuotationHelper.Create(0.0m, FloatingCashflowMetrics.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();
//Set the cash flow details.
HasReset = modelData.ValuationDate > ResetDate;
IsRealised = HasBeenRealised(ModelData.ValuationDate);
TimeToExpiry = GetPaymentYearFraction(ModelData.ValuationDate, AdjustedFixingDate);
var volatilityCurveNodeTime = GetPaymentYearFraction(ModelData.ValuationDate, PaymentDate);
IFxCurve fxCurve = null;
IRateCurve discountCurve = null;
IFxCurve currencyCurve = null;
IVolatilitySurface volSurface = null;
var metrics = ResolveModelMetrics(AnalyticsModel.Metrics);
//var metricsToEvaluate = metrics.ToArray();
//if (metricsToEvaluate.Length > 0)
//{
YearFractionToCashFlowPayment = GetPaymentYearFraction(ModelData.ValuationDate, PaymentDate);
var reportingCurrency = ModelData.ReportingCurrency == null
? PaymentCurrency.Value
: ModelData.ReportingCurrency.Value;
decimal?premium = null;
if (Premium != null)
{
premium = Premium;
}
IFxRateCashflowParameters analyticModelParameters = new FxRateCashflowParameters
{
ValuationDate = modelData.ValuationDate,
PaymentDate = PaymentDate,
Currency = PaymentCurrency.Value,
ReportingCurrency = reportingCurrency,
IsRealised = IsRealised,
IsReset = HasReset,
NotionalAmount = NotionalAmount.amount,
CurveYearFraction = YearFractionToCashFlowPayment,
ExpiryYearFraction = TimeToExpiry,
Premium = premium
};
// Curve Related
if (modelData.MarketEnvironment.GetType() == typeof(MarketEnvironment))
{
var market = (MarketEnvironment)modelData.MarketEnvironment;
discountCurve = (IRateCurve)market.SearchForPricingStructureType(DiscountCurveName);
discountCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
volSurface = (IVolatilitySurface)market.SearchForPricingStructureType(VolatilitySurfaceName);
volSurface.PricingStructureEvolutionType = PricingStructureEvolutionType;
var currencyCurveName = MarketEnvironmentHelper.ResolveFxCurveNames(StartFxRate.quotedCurrencyPair.currency1.Value,
StartFxRate.quotedCurrencyPair.currency2.Value);
currencyCurve = (IFxCurve)market.SearchForPricingStructureType(currencyCurveName);
currencyCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
analyticModelParameters.DiscountCurve = discountCurve;
if (delta1PDH)
{
var riskMarket = market.SearchForPerturbedPricingStructures(DiscountCurveName, "delta1PDH");
analyticModelParameters.Delta1PDHCurves = riskMarket;
analyticModelParameters.Delta1PDHPerturbation = 10;
}
if (delta0PDH)//TODO Do this for the fxrate
{
//var riskMarket = market.SearchForPerturbedPricingStructures(DiscountCurveName, "delta0PDH");
// //TODO The fx deltas
//analyticModelParameters.Delta1PDHCurves = riskMarket;
//analyticModelParameters.Delta1PDHPerturbation = 10;
}
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;
}
if (HybridValuation)
{
var currency1RateCurve =
(IRateCurve)market.SearchForPricingStructureType(Currency1DiscountCurveName);
currency1RateCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
var currency2RateCurve =
(IRateCurve)market.SearchForPricingStructureType(Currency2DiscountCurveName);
currency2RateCurve.PricingStructureEvolutionType = PricingStructureEvolutionType;
AnalyticsModel = new FxOptionAnalytic(ModelData.ValuationDate, PaymentDate, currencyCurve, currency1RateCurve,
currency2RateCurve, IsSettlementInCurrency1, !InvertFxRate, Strike, TimeToExpiry, volatilityCurveNodeTime, volSurface, FxOptionType, fxCurve);
}
}
// store inputs and results from this run
AnalyticModelParameters = analyticModelParameters;
if (!HybridValuation)
{
AnalyticsModel = new FxOptionAnalytic(ModelData.ValuationDate, PaymentDate, Strike, TimeToExpiry, volatilityCurveNodeTime,
fxCurve, currencyCurve, discountCurve, volSurface, FxOptionType);
} //TODO Fix this with a generic index curve.
//AnalyticsModel = analyticsModel;
CalculationResults =
AnalyticsModel.Calculate <IFloatingCashflowResults, FloatingCashflowResults>(
AnalyticModelParameters, metrics.ToArray());
CalculationPerformedIndicator = true;
PaymentDiscountFactor = ((FxRateCashflowAnalytic)AnalyticsModel).PaymentDiscountFactor;
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);
}
