private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var valuationParameter = TradeInfo.ValuationParameters;
var bondMktData = prebuiltMarket.BondPrices[TradeInfo.TradeId];
var volsurf = prebuiltMarket.VolSurfaces[valuationParameter.VolSurfNames[0]];
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.DiscountCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.FixingCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.DividendCurves.Value = new Dictionary <string, IYieldCurve> {
{ "", prebuiltMarket.YieldCurves[valuationParameter.DividendCurveNames[0]] }
},
x => x.RiskfreeCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.VolSurfaces.Value = new Dictionary <string, IVolSurface> {
{ "", volsurf }
},
x => x.MktQuote.Value = new Dictionary <string, Tuple <PriceQuoteType, double> > {
{ TradeInfo.TradeId, Tuple.Create((bondMktData == null || string.IsNullOrEmpty(bondMktData.PriceQuoteType)) ? PriceQuoteType.None : bondMktData.PriceQuoteType.ToPriceQuoteType(), (bondMktData == null ? 100.0 : bondMktData.Quote)) }
},
x => x.SpotPrices.Value = new Dictionary <string, double> {
{ "", prebuiltMarket.StockPrices[valuationParameter.UnderlyingId] }
},
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates
));
}
private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var valuationParameter = TradeInfo.ValuationParamters;
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.DiscountCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.FixingCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates));
}
private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var ticker = TradeInfo.UnderlyingTicker;
var spot = prebuiltMarket.StockPrices[ticker];
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.SpotPrices.Value = new Dictionary <string, double> {
{ "", spot }
}
));
}
private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var recTicker = TradeInfo.RecTicker;
var payTicker = TradeInfo.PayTicker;
var fxTicker = TradeInfo.FxTicker;
var recLegSpot = prebuiltMarket.StockPrices[recTicker];
var payLegSpot = prebuiltMarket.StockPrices[payTicker];
var fx = prebuiltMarket.FxSpots[fxTicker];
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.SpotPrices.Value = new Dictionary <string, double> {
{ recTicker, recLegSpot }, { payTicker, payLegSpot }
},
x => x.FxSpot.Value = new Dictionary <string, double> {
{ fxTicker, fx }
}
));
}
private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var valuationParameter = TradeInfo.ValuationParamters;
BondMktData bondMktData = null;
if (prebuiltMarket.BondPrices.ContainsKey(TradeInfo.TradeId))
{
bondMktData = prebuiltMarket.BondPrices[TradeInfo.TradeId];
}
if (valuationParameter == null)
{
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.DiscountCurve.Value = null,
x => x.FixingCurve.Value = null,
x => x.RiskfreeCurve.Value = null,
x => x.MktQuote.Value = new Dictionary <string, Tuple <PriceQuoteType, double> > {
{ TradeInfo.TradeId, Tuple.Create((bondMktData == null || string.IsNullOrEmpty(bondMktData.PriceQuoteType)) ? PriceQuoteType.None : bondMktData.PriceQuoteType.ToPriceQuoteType(), (bondMktData == null ? 100.0 : bondMktData.Quote)) }
},
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates));
}
var fixingCurveName = string.IsNullOrEmpty(valuationParameter.FixingCurveName)
? valuationParameter.DiscountCurveName
: valuationParameter.FixingCurveName;
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.DiscountCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.FixingCurve.Value = prebuiltMarket.YieldCurves[fixingCurveName],
x => x.RiskfreeCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.RiskfreeCurveName],
x => x.MktQuote.Value = new Dictionary <string, Tuple <PriceQuoteType, double> > {
{ TradeInfo.TradeId, Tuple.Create((bondMktData == null || string.IsNullOrEmpty(bondMktData.PriceQuoteType)) ? PriceQuoteType.None : bondMktData.PriceQuoteType.ToPriceQuoteType(), (bondMktData == null ? 100.0 : bondMktData.Quote)) }
},
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates
));
}
public static Dictionary <string, PnLResultBase> DoPnLExplain(string[] tradeIds,
PrebuiltQdpMarket t0Mkt,
PrebuiltQdpMarket t1Mkt,
PrebuiltQdpMarket t0MktDateRolledFwd,
PrebuiltQdpMarket t0MktRolldownForBond,
PrebuiltQdpMarket t0MktPriceNow = null,
PrebuiltQdpMarket t0MktPriceVolNow = null,
PrebuiltQdpMarket t0MktVolNow = null)
{
//TODO: add the following for more exotic product where rate/price interplay is more pronounced
//resultRateNow, resultPriceRateNow, resultVolRateNow, resultPriceVolRateNow
var useRevalPnLFramework = (t0MktPriceNow != null && t0MktVolNow != null && t0MktPriceVolNow != null);
//use reval for pnl attribution
//PnL = PriceImpact + VolImpact + PriceVolCrossImpact + Unexplained
var ret = new Dictionary <string, PnLResultBase>();
var tMarketName = t0Mkt.MarketName;
var t1MarketName = t1Mkt.MarketName;
var t0Vals = new Dictionary <string, IPricingResult>();
var t0ValsRolledForward = new Dictionary <string, IPricingResult>();
var t1Vals = new Dictionary <string, IPricingResult>();
var t0ValsPriceNow = new Dictionary <string, IPricingResult>();
var t0RolldownPriceForBond = new Dictionary <string, IPricingResult>();
var t0ValsVolNow = new Dictionary <string, IPricingResult>();
var t0ValsPriceVolNow = new Dictionary <string, IPricingResult>();
//use minimium price request to make it faster
#region requests
var pricingRequest =
PricingRequest.Pv |
PricingRequest.Cashflow |
PricingRequest.DirtyPrice |
PricingRequest.KeyRateDv01 |
PricingRequest.DollarDuration |
PricingRequest.DollarConvexity |
PricingRequest.Delta |
PricingRequest.Gamma |
PricingRequest.Vega |
PricingRequest.Theta |
PricingRequest.Rho |
PricingRequest.DVegaDvol | //one high order risk
PricingRequest.ZeroSpread |
PricingRequest.ZeroSpreadDelta |
PricingRequest.AiEod |
PricingRequest.Basis |
PricingRequest.CheapestToDeliver |
PricingRequest.Ytm |
PricingRequest.UnderlyingPv |
PricingRequest.Carry;
#endregion requests
foreach (var tradeId in tradeIds)
{
t0Vals[tradeId] = xl_ValueTrade(tradeId, t0Mkt, pricingRequest);
var t1Request = PricingRequest.Pv | PricingRequest.DirtyPrice | PricingRequest.ZeroSpread | PricingRequest.AiEod
| PricingRequest.Ytm | PricingRequest.Basis | PricingRequest.Cashflow;
t1Vals[tradeId] = xl_ValueTrade(tradeId, t1Mkt, t1Request);
t0ValsRolledForward[tradeId] = xl_ValueTrade(tradeId, t0MktDateRolledFwd, PricingRequest.Pv | PricingRequest.DirtyPrice | PricingRequest.UnderlyingPv);
//reval framework for better pnl attribution
if (useRevalPnLFramework)
{
t0ValsPriceNow[tradeId] = xl_ValueTrade(tradeId, t0MktPriceNow, PricingRequest.Pv);
t0ValsVolNow[tradeId] = xl_ValueTrade(tradeId, t0MktVolNow, PricingRequest.Pv);
t0ValsPriceVolNow[tradeId] = xl_ValueTrade(tradeId, t0MktPriceVolNow, PricingRequest.Pv);
t0RolldownPriceForBond[tradeId] = xl_ValueTrade(tradeId, t0MktRolldownForBond, PricingRequest.Pv | PricingRequest.ZeroSpread);
}
}
//For old interface:
//var tCurves = GetXlMarket(tMarketName).MarketInfo.YieldCurveDefinitions.Select(x => x.Name)
// .Select(x => t0Mkt.GetData<CurveData>(x).YieldCurve).ToDictionary(x => x.Name, x => x);
//var t1Curves = GetXlMarket(t1MarketName).MarketInfo.YieldCurveDefinitions.Select(x => x.Name)
// .Select(x => t1Mkt.GetData<CurveData>(x).YieldCurve).ToDictionary(x => x.Name, x => x);
var tCurves = t0Mkt.YieldCurves;
var t1Curves = t1Mkt.YieldCurves;
var curveMoveScaling = 1e4;
foreach (var tradeId in tradeIds)
{
var t1cf = (t1Vals[tradeId].Cashflows != null) ?
t1Vals[tradeId].Cashflows.Where(x => x.PaymentDate <= t1Mkt.ReferenceDate && x.PaymentDate > t0Mkt.ReferenceDate).Sum(x => x.PaymentAmount) :
0.0;
var tradeInfo = GetTrade(tradeId);
if (tradeInfo is InterestRateSwapInfo || tradeInfo is BondInfoBase || tradeInfo is BondFuturesInfo)
{
//PnL using bond discounted cash flows
//curve risk is between T0_{prime} and T1
var _tPv = t0Vals[tradeId].Pv;
var _t1Pv = t1Vals[tradeId].Pv;
var _tPvRecalib = t0ValsRolledForward[tradeId].Pv;
var curvePnL = new Dictionary <string, CurveRisk[]>();
foreach (var curveRiskse in t0Vals[tradeId].KeyRateDv01)
{
var tCurve = tCurves[curveRiskse.Key];
var t1Curve = t1Curves[curveRiskse.Key];
curvePnL[curveRiskse.Key] =
curveRiskse.Value.Select(x =>
new CurveRisk(
x.Tenor,
x.Risk * (t1Curve[x.Tenor] - tCurve[x.Tenor]) * curveMoveScaling
)).ToArray();
}
//include raw t1 curve risks in result
foreach (var curveRisks in t0Vals[tradeId].KeyRateDv01)
{
curvePnL[curveRisks.Key + "KeyRateDv01"] = curveRisks.Value;
}
var pnLCurve = new CommonPnLResult(_tPv, _t1Pv, _tPvRecalib - _tPv, t1cf, curvePnL);
ret[tradeId] = pnLCurve;
}
if (tradeInfo is InterestRateSwapInfo)
{
var swap = tradeInfo as InterestRateSwapInfo;
//carry & roll down
var rollDown = t0ValsRolledForward[tradeId].Pv - t0Vals[tradeId].Pv;
var carry = t0Vals[tradeId].Carry;
var pnlTime = rollDown + carry;
var commonPnl = ret[tradeId];
var pnlPv01 =
ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0
? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk)
: 0.0;
var pnl = new SwapPnLResult(commonPnl.TPv, commonPnl.T1Pv, pnlTime: pnlTime, t1Cf: t1cf, pnlPv01: pnlPv01,
pnlCarry: carry, pnlRolldown: rollDown);
ret[tradeId + "durationConvexity"] = pnl;
}
if (tradeInfo is BondInfoBase)
{
var bond = tradeInfo as BondInfoBase;
var tPv = t0Vals[tradeId].DirtyPrice;
var t1Pv = t1Vals[tradeId].DirtyPrice;
var tPvRecalib = t0ValsRolledForward[tradeId].DirtyPrice;
//bond market PnL
var pnlPv01 =
ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0
? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk)
: 0.0;
//bond specific pnl
var tZSpread = t0Vals[tradeId].ZeroSpread;
var t1ZSpread = t1Vals[tradeId].ZeroSpread;
var tZSpreadDelta = t0Vals[tradeId].ZeroSpreadDelta;
var zSpreadPnl = tZSpreadDelta * (t1ZSpread - tZSpread) * curveMoveScaling;
var pnlCarry = t1Vals[tradeId].Ai - t0Vals[tradeId].Ai;
//bond roll down effect: cashflow less, but benefit from still curve, note that zspread also changes due to rolling down the curve
var pnlRolldown = t0RolldownPriceForBond[tradeId].Pv - t0Vals[tradeId].Pv +
tZSpreadDelta * (t0RolldownPriceForBond[tradeId].ZeroSpread - tZSpread) * curveMoveScaling;
var pnlTime = pnlCarry + pnlRolldown;
//duration pnl is not used in book level pnl explain
var pnlDuration = t0Vals[tradeId].ModifiedDuration * (t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm) * bond.Notional;
var pnlConverixy = 0.5 * Math.Pow(t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm, 2.0) * t0Vals[tradeId].DollarConvexity / 100.0;
var explainedPriceImpact = pnlPv01 + zSpreadPnl + pnlConverixy + pnlTime;
var pnl = new BondPnLResult(tPv, t1Pv, pnlTime: pnlTime, t1Cf: t1cf, pnlPv01: pnlPv01, pnlZspread: zSpreadPnl, pnlCarry: pnlCarry, pnlRolldown: pnlRolldown,
pnlDuration: pnlDuration, pnlConvexity: pnlConverixy);
ret[tradeId + "durationConvexity"] = pnl;
}
if (tradeInfo is BondFuturesInfo)
{
var tPv = t0Vals[tradeId].DirtyPrice;
var t1Pv = t1Vals[tradeId].DirtyPrice;
//curve pnl
var pnlPv01 =
ret.ContainsKey(tradeId) && ret[tradeId].YieldCurvePnL.Count > 0
? ret[tradeId].YieldCurvePnL.First().Value.Sum(x => x.Risk)
: 0.0;
//zspread pnl from CTD, converted to future equivalen t
var zspreadT0 = t0Vals[tradeId].ZeroSpread;
var zspreadT1 = t1Vals[tradeId].ZeroSpread;
var zspreadPnl = (zspreadT1 - zspreadT0) * curveMoveScaling * t0Vals[tradeId].ZeroSpreadDelta;
//basis pnl from CTD/cf - Future
var basisT0 = t0Vals[tradeId].Basis;
var basisT1 = t1Vals[tradeId].Basis;
var bondFut = XlManager.GetTrade(tradeId) as BondFuturesInfo;
var futPosScaling = 1.0 / 100.0 * bondFut.Notional;
var basisPnL = (basisT1 - basisT0) * futPosScaling;
//convexity pnl from CTD
var ctdId = t0Vals[tradeId].CheapestToDeliver;
var pnlConvexity = 0.0;
var bondMktData = t0Mkt.BondPrices[ctdId];
if (bondMktData != null)
{
var ctdCleanPriceT0 = bondMktData.CleanPrice;
var ctdInfo = bondFut.DeliverableBondInfos.Where(x => x.BondId == ctdId).First();
var ctdResultT0 = XlUdf.BondEngineCalc(ctdId, t0Mkt.ReferenceDate.ToString(),
PriceQuoteType.Clean, ctdCleanPriceT0, PricingRequest.DirtyPrice,
fixedBond: ctdInfo) as PricingResult;
pnlConvexity = 0.5 * Math.Pow(t1Vals[tradeId].Ytm - t0Vals[tradeId].Ytm, 2.0) * t0Vals[tradeId].DollarConvexity / 100.0;
}
//time pnl from CTD
var timePnL = t0ValsRolledForward[tradeId].UnderlyingPv - t0Vals[tradeId].UnderlyingPv;
var pnl = new BondFuturesPnLResult(tPv, t1Pv, pnlPv01: pnlPv01, pnlZspread: zspreadPnl, pnlBasis: basisPnL,
pnlTime: timePnL, pnlConvexity: pnlConvexity, curveRisks: null);
ret[tradeId] = pnl;
}
if (tradeInfo is VanillaOptionInfo || tradeInfo is BinaryOptionInfo || GetTrade(tradeId) is BarrierOptionInfo || tradeInfo is AsianOptionInfo)
{
OptionValuationParameters valuationParameters = null;
Date exerciseDate = null;
double strike = 0.0;
var trade = tradeInfo as OptionInfoBase;
valuationParameters = trade.ValuationParamter;
TradeUtil.GenerateOptionDates(trade, out Date[] exerciseDates, out Date[] obsDates, out DayGap settlementGap);
/// <summary>
/// for Option version only
/// </summary>
/// <param name="prebuiltMarket"></param>
/// <param name="curveDate"></param>
/// <param name="curveDefinition"></param>
/// <returns></returns>
public static YieldCurve BuildYieldCurve(PrebuiltQdpMarket prebuiltMarket, Date curveDate, InstrumentCurveDefinition curveDefinition)
{
IMarketCondition baseMarket;
baseMarket = new MarketCondition(x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates);
YieldCurve instrumentCurve = null;
if (curveDefinition.RateDefinitions.All(
x => x.InstrumentType.ToInstrumentType() == InstrumentType.Dummy || x.InstrumentType.ToInstrumentType() == InstrumentType.None))
{
if (curveDefinition.RateDefinitions.All(x => x.IsTerm()))
{
instrumentCurve = new YieldCurve(
curveDefinition.Name,
curveDate,
curveDefinition.RateDefinitions.Select(x => Tuple.Create((ITerm) new Term(x.Tenor), x.Rate)).ToArray(),
curveDefinition.CurveConvention.BusinessDayConvention.ToBda(),
curveDefinition.CurveConvention.DayCount.ToDayCountImpl(),
curveDefinition.CurveConvention.Calendar.ToCalendarImpl(),
curveDefinition.CurveConvention.Currency.ToCurrencyCode(),
curveDefinition.CurveConvention.Compound.ToCompound(),
curveDefinition.CurveConvention.Interpolation.ToInterpolation(),
curveDefinition.Trait.ToYieldCurveTrait(),
null,
null,
null,
null,
curveDefinition
);
}
else
{
instrumentCurve = new YieldCurve(
curveDefinition.Name,
curveDate,
curveDefinition.RateDefinitions.Select(x => Tuple.Create(new Date(DateTime.Parse(x.Tenor)), x.Rate)).ToArray(),
curveDefinition.CurveConvention.BusinessDayConvention.ToBda(),
curveDefinition.CurveConvention.DayCount.ToDayCountImpl(),
curveDefinition.CurveConvention.Calendar.ToCalendarImpl(),
curveDefinition.CurveConvention.Currency.ToCurrencyCode(),
curveDefinition.CurveConvention.Compound.ToCompound(),
curveDefinition.CurveConvention.Interpolation.ToInterpolation(),
curveDefinition.Trait.ToYieldCurveTrait(),
null,
null,
null,
null,
curveDefinition
);
}
}
else
{
var mktInstruments = new List <MarketInstrument>();
foreach (var rateDefinition in curveDefinition.RateDefinitions)
{
MktInstrumentCalibMethod calibrationMethod;
if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.InterestRateSwap)
{
var swap = CurveBuildHelper.CreateIrsInstrument(curveDate, rateDefinition, out calibrationMethod);
mktInstruments.Add(new MarketInstrument(swap, rateDefinition.Rate, calibrationMethod));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.Deposit ||
rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.Repo ||
rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.Ibor)
{
var deposit = CurveBuildHelper.CreateDepositInstrument(curveDate, rateDefinition, out calibrationMethod);
mktInstruments.Add(new MarketInstrument(deposit, rateDefinition.Rate, calibrationMethod));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.Dummy ||
rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.None)
{
var dummy = CurveBuildHelper.CreateDummyInstrument(curveDate, rateDefinition);
mktInstruments.Add(new MarketInstrument(dummy, rateDefinition.Rate, MktInstrumentCalibMethod.Default));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.CreditDefaultSwap)
{
var cds = CurveBuildHelper.CreateCreditDefaultSwap(curveDate, rateDefinition);
mktInstruments.Add(new MarketInstrument(cds, rateDefinition.Rate, MktInstrumentCalibMethod.Default));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.CommodityForward)
{
mktInstruments.Add(new MarketInstrument(CurveBuildHelper.CreateCommodityForward(curveDate, rateDefinition), rateDefinition.Rate, MktInstrumentCalibMethod.Default));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.CommoditySpot)
{
//baseMarket = baseMarket.UpdateCondition(new UpdateMktConditionPack<double>(x => x.SpotPrice, rateDefinition.Rate));
}
else if (rateDefinition.InstrumentType.ToInstrumentType() == InstrumentType.FxSpot)
{
}
else
{
throw new PricingLibraryException("Unrecognized product type in calibrating curve.");
}
}
var isSpcCurve = curveDefinition.RateDefinitions.All(x => x.IndexType != null && x.IndexType.ToIndexType() == IndexType.Spc);
var isConvenicenYield = curveDefinition.RateDefinitions.All(x => x.IndexType != null && x.IndexType.ToIndexType() == IndexType.ConvenienceYield);
//Expression<Func<IMarketCondition, object>>[] expression = null;
//if (isSpcCurve) expression = new Expression<Func<IMarketCondition, object>>[] { x => x.SurvivalProbabilityCurve };
//if (isConvenicenYield) expression = new Expression<Func<IMarketCondition, object>>[] { x => x.DividendCurve };
instrumentCurve = new YieldCurve(
curveDefinition.Name,
curveDate,
mktInstruments.ToArray(),
curveDefinition.CurveConvention.BusinessDayConvention.ToBda(),
curveDefinition.CurveConvention.DayCount.ToDayCountImpl(),
curveDefinition.CurveConvention.Calendar.ToCalendarImpl(),
curveDefinition.CurveConvention.Currency.ToCurrencyCode(),
curveDefinition.CurveConvention.Compound.ToCompound(),
curveDefinition.CurveConvention.Interpolation.ToInterpolation(),
curveDefinition.Trait.ToYieldCurveTrait(),
baseMarket,
null,
null,
null,
null,
curveDefinition);
}
return(instrumentCurve);
}
private IMarketCondition GenerateMarketConditionFromPrebuilt(PrebuiltQdpMarket prebuiltMarket)
{
var valuationParameter = TradeInfo.ValuationParamters;
var mktQuote = new Dictionary <string, Tuple <PriceQuoteType, double> >();
try
{
if (prebuiltMarket.BondFuturePrices.ContainsKey(TradeInfo.TradeId))
{
var futurePrice = prebuiltMarket.BondFuturePrices[TradeInfo.TradeId];
mktQuote[TradeInfo.TradeId] = Tuple.Create(PriceQuoteType.Dirty, futurePrice);
}
else
{
mktQuote[TradeInfo.TradeId] = null;
}
foreach (var deliverableBondInfo in TradeInfo.DeliverableBondInfos)
{
//var bondMktData =
BondMktData bondMktData = null;
if (prebuiltMarket.BondPrices.ContainsKey(deliverableBondInfo.TradeId))
{
bondMktData = prebuiltMarket.BondPrices[deliverableBondInfo.TradeId];
}
if (bondMktData != null)
{
mktQuote[deliverableBondInfo.TradeId] = Tuple.Create(bondMktData.PriceQuoteType.ToPriceQuoteType(), bondMktData.Quote);
}
var tfBondId = TradeInfo.TradeId + "_" + deliverableBondInfo.TradeId;
BondMktData tfMktData = null;
if (prebuiltMarket.BondPrices.ContainsKey(tfBondId))
{
tfMktData = prebuiltMarket.BondPrices[tfBondId];
}
if (tfMktData != null)
{
mktQuote[tfBondId] = Tuple.Create(tfMktData.PriceQuoteType.ToPriceQuoteType(), tfMktData.Quote);
}
}
}
catch (Exception ex)
{
throw new PricingBaseException(string.Format("Market price is missing, detailed message: {0}", ex.Message));
}
var fixingCurveName = valuationParameter.FixingCurveName;
if (string.IsNullOrEmpty(fixingCurveName))
{
fixingCurveName = valuationParameter.DiscountCurveName;
}
return(new MarketCondition(
x => x.ValuationDate.Value = prebuiltMarket.ReferenceDate,
x => x.DiscountCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.DiscountCurveName],
x => x.FixingCurve.Value = prebuiltMarket.YieldCurves[fixingCurveName],
x => x.RiskfreeCurve.Value = prebuiltMarket.YieldCurves[valuationParameter.RiskfreeCurveName],
x => x.MktQuote.Value = mktQuote,
x => x.HistoricalIndexRates.Value = prebuiltMarket.HistoricalIndexRates
));
}
