private static void LoadHolidays(ILogger logger, ICoreCache client, Assembly assembly) { const string FileName = "Holidays.xml"; string holidaysXml = ResourceHelper.GetResourceWithPartialName(assembly, FileName); // load daterules from file LocationCalendarYears calendarYears = XmlSerializerHelper.DeserializeFromString <LocationCalendarYears>(holidaysXml); foreach (LocationCalendarYear locationCalendarYear in calendarYears.LocationCalendarYear) { string name; NamedValueSet itemProps = CreateProperties(locationCalendarYear, out name); client.SaveObject <LocationCalendarYear>(locationCalendarYear, name, itemProps, TimeSpan.MaxValue); } logger.LogDebug("Loaded holidays."); }
/// <summary> /// Initializes a new instance of the <see cref="CapVolatilityCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The nameSpace</param> /// <param name="curveIdentifier">The curveIdentifier.</param> protected CapVolatilityCurve(ILogger logger, ICoreCache cache, String nameSpace, PricingStructureIdentifier curveIdentifier) : base(logger, cache, nameSpace, curveIdentifier) { BootstrapperName = "CapFloorBootstrapper"; UnderlyingInterpolatedCurve = "CapVolatilityCurve"; var properties = curveIdentifier.GetProperties(); PricingStructureData = new PricingStructureData(CurveType.Parent, AssetClass.Rates, properties); Tolerance = PropertyHelper.ExtractDoubleProperty("Tolerance", properties) ?? GetDefaultTolerance(Holder); var compoundingFrequency = properties.GetString("CompoundingFrequency", null); CompoundingFrequency = compoundingFrequency != null ? EnumHelper.Parse <CompoundingFrequencyEnum>(compoundingFrequency) : GetDefaultCompounding(Holder); }
/// <summary> /// Derives the adjusted date if not already provided. /// </summary> /// <param name="baseDate">The base date is settlement is relative.</param> /// <param name="adjustableOrAdjustedDate">this may contain the adjustedDate, an unadjustedDate and business Centre</param> /// <param name="cache">THe cache if the business calendar has not already been calculated.</param> /// <param name="nameSpace">The client nameSpace</param> /// <param name="businessCalendar">THe business calendar must be provided, no namespace is required and can be null</param> /// <returns></returns> public static DateTime?GetAdjustedDate(ICoreCache cache, string nameSpace, IBusinessCalendar businessCalendar, DateTime?baseDate, AdjustableOrRelativeDate adjustableOrAdjustedDate) { if (adjustableOrAdjustedDate.Item is AdjustableDate date) { return(GetAdjustedDate(cache, nameSpace, businessCalendar, date)); } if (adjustableOrAdjustedDate.Item is RelativeDateOffset relativeDate && baseDate != null) { return(GetAdjustedDate(cache, nameSpace, businessCalendar, baseDate, relativeDate)); } return(null); }
private void AddCashFlows(ILogger logger, ICoreCache cache, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, Fra fraFpML, bool isBuyer, String nameSpace) { EffectiveDate = fraFpML.adjustedEffectiveDate.Value; TerminationDate = fraFpML.adjustedTerminationDate; if (paymentCalendar == null) { paymentCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fraFpML.paymentDate.dateAdjustments.businessCenters, nameSpace); } if (fixingCalendar == null) { fixingCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, fraFpML.fixingDateOffset.businessCenters, nameSpace); } DateTime unadjustedPaymentDate = fraFpML.paymentDate.unadjustedDate.Value; var notional = MoneyHelper.GetAmount(fraFpML.notional.amount, fraFpML.notional.currency); PaymentDate = paymentCalendar.Roll(unadjustedPaymentDate, BusinessDayConventionHelper.Parse(fraFpML.paymentDate.dateAdjustments.businessDayConvention.ToString())); DateTime adjustedFixingDate = GetResetDate(logger, cache, fixingCalendar, fraFpML, nameSpace); var interval = fraFpML.indexTenor[0]; var floatingInterest = new PriceableFloatingRateCoupon(fraFpML.id + "FloatingCoupon_1" , isBuyer , EffectiveDate , TerminationDate , adjustedFixingDate , fraFpML.dayCountFraction , 0.0m , FixedRate , null , isBuyer ? MoneyHelper.Neg(notional) : notional , PaymentDate , new ForecastRateIndex { floatingRateIndex = fraFpML.floatingRateIndex, indexTenor = interval } , null , null , fraFpML.fraDiscounting , paymentCalendar , fixingCalendar) { ForecastRateInterpolation = ForecastRateInterpolation }; // Combine two cashflows into one leg // FloatingCoupon = floatingInterest;//fraFpML.fraDiscounting, }
/// <summary> /// Create a series of Volatility engines from a raw volatility grid and a DF curve /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="properties">The properties of the engine, including the reference handle to access this engine collection</param> /// <param name="instruments">An array of instrument types.</param> /// <param name="rawVolatilityGrid">The raw grid used to build the engines. Assume that all volatility and strike values are 100x true</param> /// <returns>The engine handle or an error message</returns> public string CreateVolatilityCurve(ILogger logger, ICoreCache cache, string nameSpace, NamedValueSet properties, String[] instruments, Decimal[,] rawVolatilityGrid) { var id = properties.GetString(CurveProp.EngineHandle, null); var baseDate = properties.GetValue <DateTime>(CurveProp.BaseDate, true); var valuationDate = properties.GetValue(CurveProp.ValuationDate, DateTime.MinValue); if (valuationDate == DateTime.MinValue) { properties.Set(CurveProp.ValuationDate, baseDate); } var strikeQuoteUnits = properties.GetString(CurveProp.StrikeQuoteUnits, null); if (strikeQuoteUnits == null) { properties.Set(CurveProp.StrikeQuoteUnits, StrikeQuoteUnitsEnum.ATMFlatMoneyness.ToString()); } var measureType = properties.GetString(CurveProp.MeasureType, null); if (measureType == null) { properties.Set(CurveProp.MeasureType, MeasureTypesEnum.Volatility.ToString()); } var quoteUnits = properties.GetString(CurveProp.QuoteUnits, null); if (quoteUnits == null) { properties.Set(CurveProp.QuoteUnits, QuoteUnitsEnum.LogNormalVolatility.ToString()); } var algorithm = properties.GetString(CurveProp.Algorithm, null); if (algorithm == null) { properties.Set(CurveProp.Algorithm, "Default"); } var volatilities = GenerateVolatilityMatrix(instruments, 0, rawVolatilityGrid); // Create the engines and either add to, or overwrite the existing, collection if (_volCurveEngines.ContainsKey(id)) { _volCurveEngines[id] = VolatilityCurveCreate(logger, cache, nameSpace, properties, instruments, volatilities); } else { _volCurveEngines.Add(id, VolatilityCurveCreate(logger, cache, nameSpace, properties, instruments, volatilities)); } return(id); }
public static void BuildTrade(ILogger logger, ICoreCache targetClient, Trade tradeVersion, Party[] party) { var extraProps = new NamedValueSet(); var party1 = party[0].partyId[0].Value; var party2 = party[1].partyId[0].Value; extraProps.Set(TradeProp.Party1, party1); extraProps.Set(TradeProp.Party2, party2); //extraProps.Set(TradeProp.CounterPartyId, party2);//Redundant //extraProps.Set(TradeProp.OriginatingPartyId, party1);//Redundant extraProps.Set(TradeProp.TradeDate, tradeVersion.tradeHeader.tradeDate.Value); extraProps.Set(TradeProp.TradingBookName, "Test"); TradeId tradeId; var tempId = tradeVersion.tradeHeader.partyTradeIdentifier[0].Items[0]; if (tempId as VersionedTradeId == null) { tradeId = (TradeId)tradeVersion.tradeHeader.partyTradeIdentifier[0].Items[0]; } else { var id = (VersionedTradeId)tradeVersion.tradeHeader.partyTradeIdentifier[0].Items[0]; tradeId = id.tradeId; } //tradeId = (TradeId)tradeVersion.tradeHeader.partyTradeIdentifier[0].Items[0]; extraProps.Set(TradeProp.TradeState, "Pricing"); //extraProps.Set("TradeType", "Deposit"); extraProps.Set(TradeProp.TradeSource, "FPMLSamples"); extraProps.Set(TradeProp.TradeId, tradeId.Value); extraProps.Set(TradeProp.BaseParty, TradeProp.Party1); //party1 extraProps.Set(TradeProp.CounterPartyName, TradeProp.Party2); //party2 extraProps.Set(TradeProp.AsAtDate, DateTime.Today); var tradeType = ProductTypeHelper.TradeTypeHelper(tradeVersion.Item); var currencies = tradeVersion.Item.GetRequiredCurrencies().ToArray(); var curves = tradeVersion.Item.GetRequiredPricingStructures().ToArray(); extraProps.Set(TradeProp.RequiredPricingStructures, curves); extraProps.Set(TradeProp.RequiredCurrencies, currencies); extraProps.Set(TradeProp.TradeType, tradeType.ToString()); //extraProps.Set(TradeProp.ProductType, tradeType.ToString()); string idSuffix = String.Format("{0}.{1}", tradeType, tradeId.Value); ItemInfo itemInfo = MakeTradeProps("Trade", idSuffix, extraProps); logger.LogDebug(" {0} ...", idSuffix); targetClient.SaveObject(tradeVersion, itemInfo.ItemName, itemInfo.ItemProps, false, TimeSpan.MaxValue); }
/// <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>(); 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); //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(); } if (swaptionFpML.Item1 is CashSettlement) { IsCashSettled = true;//TODO extend to the type of calculation. } }
/// <summary> /// Initializes a new instance of the <see cref="RateBasisCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="referenceCurve">The reference parent curve id.</param> /// <param name="spreadAssets">The spreads by asset.</param> /// <param name="properties">The properties of the new spread curve.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public RateBasisCurve(ILogger logger, ICoreCache cache, string nameSpace, IRateCurve referenceCurve, QuotedAssetSet spreadAssets, NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, ProcessQuotedAssetSet(logger, cache, nameSpace, referenceCurve, spreadAssets, properties, fixingCalendar, rollCalendar), properties, fixingCalendar, rollCalendar) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, properties); BaseCurve = referenceCurve; ReferenceCurveId = BaseCurve.GetPricingStructureId(); if (PricingStructureIdentifier.PricingStructureType != PricingStructureTypeEnum.RateBasisCurve) { return; } //Set the spread sets. PriceableRateSpreadAssets = PriceableAssetFactory.CreatePriceableRateSpreadAssets(logger, cache, nameSpace, PricingStructureIdentifier.BaseDate, spreadAssets, fixingCalendar, rollCalendar); Build(logger, cache, nameSpace, fixingCalendar, rollCalendar); }
/// <summary> /// Create a surface from an FpML /// </summary> /// <param name="logger"></param> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <param name="fpmlData"></param> /// <param name="properties"></param> public ExpiryTermTenorStrikeVolatilityCube(ILogger logger, ICoreCache cache, String nameSpace, Pair <PricingStructure, PricingStructureValuation> fpmlData, NamedValueSet properties) { var surfaceId = new VolatilitySurfaceIdentifier(properties); Algorithm = surfaceId.Algorithm; PricingStructureIdentifier = surfaceId; var holder = new PricingStructureAlgorithmsHolder(logger, cache, nameSpace, surfaceId.PricingStructureType, surfaceId.Algorithm); Algorithm = "Linear"; //Add as a propert in the id. var curveInterpolationMethod = InterpolationMethodHelper.Parse(holder.GetValue("CurveInterpolation")); var data = (VolatilityMatrix)fpmlData.Second; DateTime baseDate = data.baseDate.Value; Interpolator = new VolSurfaceInterpolator(data.dataPoints, curveInterpolationMethod, true, baseDate); SetFpMLData(fpmlData); }
/// <summary> /// Perturbed curve /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="properties">The properties of the new curve.</param> /// <param name="baseCurve">The XCcySpreadCurve that the new curve is based on</param> /// <param name="perturbations">The pertubations to the values of the base curve</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public XccySpreadCurve(ILogger logger, ICoreCache cache, String nameSpace, NamedValueSet properties, XccySpreadCurve baseCurve, decimal[] perturbations, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, new RateCurveIdentifier(properties)) { var assetQuote = ((YieldCurveValuation)baseCurve.PricingStructureValuation).inputs.assetQuote; string[] instruments = assetQuote.Where(a => a.definitionRef == null).Select(a => a.objectReference.href).ToArray(); decimal[] values = assetQuote.Where(a => a.definitionRef == null).Select(a => a.quote[0].value).ToArray(); for (int i = 0; i < values.Length; i++) { values[i] += perturbations[i]; } Initialize(logger, cache, nameSpace, properties, baseCurve.BaseCurve, baseCurve.QuoteCurve, instruments, values, null, fixingCalendar, rollCalendar); }
/// <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; 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); } PremiumPaymentAmounts = paymentAmounts.ToArray(); PremiumPaymentDates = paymentDates.ToArray(); var isCashSettled = swaptionFpML.Item1 as CashSettlement; if (isCashSettled != null) { IsCashSettled = true; } }
/// <summary> /// Initializes a new instance of the <see cref="CommodityCurve"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The client namespace</param> /// <param name="fpmlData">The FPML data.</param> /// <param name="properties">The properties.</param> /// <param name="fixingCalendar">The fixingCalendar.</param> /// <param name="rollCalendar">The rollCalendar.</param> public CommodityCurve(ILogger logger, ICoreCache cache, string nameSpace, Pair <PricingStructure, PricingStructureValuation> fpmlData, NamedValueSet properties, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, fpmlData, new CommodityCurveIdentifier(properties)) { PricingStructureData = new PricingStructureData(CurveType.Parent, AssetClass.Commodity, properties); if (fpmlData == null) { return; } FixingCalendar = fixingCalendar; PaymentCalendar = rollCalendar; var tempFpML = (FxCurveValuation)fpmlData.Second; // Use default algorithm name // Algorithm = DefaultAlgorithName; var termCurve = SetConfigurationData(); //SetFpMLData(fpmlData); BootstrapperName = Holder.GetValue("Bootstrapper"); var bootstrap = PropertyHelper.ExtractBootStrapOverrideFlag(properties); // If there's no forward points - do build the curve. // //This is to catch it when there are no discount factor points. var discountsAbsent = tempFpML.fxForwardCurve == null || tempFpML.fxForwardCurve.point == null || tempFpML.fxForwardCurve.point.Length == 0; if (cache == null) { //optimize = true; bootstrap = false; } bool doBuild = (tempFpML.spotRate != null) && discountsAbsent; if (bootstrap || doBuild) { var qas = tempFpML.spotRate; PriceableCommodityAssets = PriceableAssetFactory.CreatePriceableCommodityAssets(logger, cache, nameSpace, tempFpML.baseDate.Value, qas, fixingCalendar, rollCalendar); var point = CommodityBootstrapper.Bootstrap(PriceableCommodityAssets, tempFpML.baseDate.Value, termCurve.extrapolationPermitted, termCurve.interpolationMethod); ((FxCurveValuation)fpmlData.Second).fxForwardCurve.point = point; } SetInterpolator(PricingStructureValuation.baseDate.Value, Holder); }
public void TestSaveLoadPrivateCacheItems() { using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true))) using (CoreServer server = new CoreServer(loggerRef, "UTT", NodeType.Router)) { server.Start(); using (ICoreClient client = new CoreClientFactory(loggerRef).SetEnv("UTT").Create()) using (ICoreCache cacheA = client.CreateCache()) { Guid id = cacheA.SavePrivateObject("data", "name1", null); //ICoreItem item = cacheA.LoadPrivateItem<string>("name1"); ICoreItem item = cacheA.LoadItem <string>("name1"); string data = (string)item.Data; Assert.AreEqual <string>("data", data); } } }
/// <summary> /// Tries to get the algorithm. /// </summary> /// <param name="nameSpace"></param> /// <param name="pricingStructureType"></param> /// <param name="algorithmName"></param> /// <param name="logger"></param> /// <param name="cache">The value</param> /// <returns>Whether the property existed or not</returns> public Algorithm GetAlgorithm(ILogger logger, ICoreCache cache, String nameSpace, PricingStructureTypeEnum pricingStructureType, string algorithmName) { Algorithm algorithm = null; if (cache != null) { try { algorithm = cache.LoadObject <Algorithm>(nameSpace + "." + AlgorithmsProp.GenericName + "." + pricingStructureType + "." + algorithmName); } catch (Exception ex) { logger.Log(ex); } } return(algorithm); }
/// <summary> /// Compute a Volatility Smile given an engine, a date and a list of strikes /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The clients namespace</param> /// <param name="engineHandle">The SABR engine to use</param> /// <param name="date">The date to compute for</param> /// <param name="strikes">The strikes that make up the smile. This can be a single strike (ATM)</param> /// <returns></returns> public List <Decimal> SABRComputeVolatility(ILogger logger, ICoreCache cache, string nameSpace, string engineHandle, DateTime date, decimal[] strikes) { SmileCalibrationEngine engine; if (_sabrEngines.ContainsKey(engineHandle)) { engine = _sabrEngines[engineHandle]; } else { throw new ArgumentException("SABR Caplet Smile Calibration engine not found."); } var strikesList = new List <decimal>(strikes); var computedValues = engine.ComputeVolatilitySmile(logger, cache, nameSpace, date, strikesList); return(computedValues); }
/// <summary> /// Derives the adjusted date if not already provided. /// </summary> /// <param name="baseDate">The base date is settlement is relative.</param> /// <param name="relativeDateOffset">this may contain the adjustedDate, an unadjustedDate and business Centre</param> /// <param name="cache">THe cache if the business calendar has not already been calculated.</param> /// <param name="nameSpace">The client nameSpace</param> /// <param name="businessCalendar">THe business calendar must be provided, no namespace is required and can be null</param> /// <returns></returns> public static DateTime?GetAdjustedDate(ICoreCache cache, string nameSpace, IBusinessCalendar businessCalendar, DateTime?baseDate, RelativeDateOffset relativeDateOffset) { if (relativeDateOffset.adjustedDate != null) { return(relativeDateOffset.adjustedDate.Value); } if (baseDate == null) { return(null); } if (businessCalendar == null) { businessCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, relativeDateOffset.businessCenters, nameSpace); } return(ToAdjustedDate(businessCalendar, (DateTime)baseDate, relativeDateOffset)); }
public ClearedRateCurve(ILogger logger, ICoreCache cache, string nameSpace, NamedValueSet properties, QuotedAssetSet instrumentData, IRateCurve baseDiscountingCurve, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar) : base(logger, cache, nameSpace, new RateCurveIdentifier(properties), fixingCalendar, rollCalendar) { PricingStructureData = new PricingStructureData(CurveType.Child, AssetClass.Rates, properties); BaseDiscountingCurve = baseDiscountingCurve; var curveId = GetRateCurveId(); var termCurve = SetConfigurationData(); var indexTenor = curveId.ForecastRateIndex?.indexTenor; PriceableClearedRateAssets = PriceableAssetFactory.CreatePriceableClearedRateAssetsWithBasisSwaps(logger, cache, nameSpace, indexTenor, instrumentData, GetRateCurveId().BaseDate, fixingCalendar, rollCalendar); termCurve.point = ClearedRateBootstrapper.Bootstrap(PriceableClearedRateAssets, BaseDiscountingCurve, curveId.BaseDate, termCurve.extrapolationPermitted, termCurve.interpolationMethod, Tolerance); CreatePricingStructure(curveId, termCurve, instrumentData); // CreatePricingStructure(curveId, termCurve, PriceableAssetFactory.Parse(PriceableClearedRateAssets)); // Interpolate the DiscountFactor curve based on the respective curve interpolation SetInterpolator(termCurve); }
/// <summary> /// Create a surface from an FpML /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">The nameSpace</param> /// <param name="fpmlData">The data.</param> /// <param name="properties">The properties.</param> protected ExpiryTermStrikeVolatilitySurface(ILogger logger, ICoreCache cache, String nameSpace, Pair <PricingStructure, PricingStructureValuation> fpmlData, NamedValueSet properties) { var data = (VolatilityMatrix)fpmlData.Second; Algorithm = "Linear";//Add as a property in the id. //Creates the property collection. This should be backward compatable with V1. var surfaceId = new VolatilitySurfaceIdentifier(properties); PricingStructureIdentifier = surfaceId; var holder = new PricingStructureAlgorithmsHolder(logger, cache, nameSpace, surfaceId.PricingStructureType, surfaceId.Algorithm); var curveInterpolationMethod = InterpolationMethodHelper.Parse(holder.GetValue("CurveInterpolation")); Interpolator = new VolSurfaceInterpolator(data.dataPoints, curveInterpolationMethod, true, PricingStructureIdentifier.BaseDate); SetFpmlData(fpmlData); _matrixIndexHelper = new SortedList <ExpiryTenorStrikeKey, int>(new ExpiryTenorStrikeKey()); ProcessVolatilityRepresentation(); }
protected override void OnFirstCallback() { // subscribe to import rules _ruleCache = IntClient.Target.CreateCache(delegate(CacheChangeData update) { Interlocked.Increment(ref _dispatchedEventCount); MainThreadQueue.Dispatch(update, ProcessRuleUpdate); }, null); _ruleCache.Subscribe <AlertRule>( RuleObject.MakeRuleFilter( EnvHelper.EnvName(IntClient.Target.ClientInfo.ConfigEnv), IntClient.Target.ClientInfo.HostName, AppName, IntClient.Target.ClientInfo.UserName)); // start a 30 second timer to periodically check the rules _timer = new Timer(RecvTimerEvent, null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30)); }
/// <summary> /// Creates the equity curve. /// </summary> /// <param name="logger">The logger.</param> /// <param name="cache">The cache.</param> /// <param name="nameSpace">THe client namespace</param> /// <param name="equityId">THe underlying curve asset.</param> /// <param name="fixingCalendar"></param> /// <param name="rollCalendar"></param> /// <param name="baseDate">The base date.</param> /// <param name="fxRates">The spot rate.</param> /// <param name="curveId">The curve id.</param> /// <param name="termCurve">The bootstrapped term curve.</param> /// <returns></returns> private static FxCurveValuation CreateEquityCurveValuation(ILogger logger, ICoreCache cache, string nameSpace, EquityCurveIdentifier equityId, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar, DateTime baseDate, FxRateSet fxRates, string curveId, TermCurve termCurve) { DateTime settlementDate = GetSettlementDate(logger, cache, nameSpace, equityId, fixingCalendar, rollCalendar, baseDate); var fxCurveValuation = new FxCurveValuation { baseDate = IdentifiedDateHelper.Create(baseDate), buildDateTime = baseDate, buildDateTimeSpecified = true, spotRate = fxRates, id = curveId, fxForwardCurve = termCurve, spotDate = IdentifiedDateHelper.Create("SettlementDate", settlementDate) }; return(fxCurveValuation); }
protected override void OnFirstCallback() { // subscribe to import rules _importRuleSet = IntClient.Target.CreateCache(delegate(CacheChangeData update) { Interlocked.Increment(ref _updateRequestsDispatched); MainThreadQueue.Dispatch(update, ProcessRuleUpdate); }, null); _importRuleSet.Subscribe <FileImportRule>( RuleObject.MakeRuleFilter( EnvHelper.EnvName(IntClient.Target.ClientInfo.ConfigEnv), IntClient.Target.ClientInfo.HostName, AppName, IntClient.Target.ClientInfo.UserName)); // start a 1 minute timer to periodically check the rules _timer = new Timer(RecvTimerEvent, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1)); }
/// <summary> /// Converts to an adjustable date type. /// </summary> /// <param name="adjustableDate"></param> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <returns></returns> public static DateTime ToAdjustedDate(ICoreCache cache, AdjustableDate adjustableDate, string nameSpace) { if (null == adjustableDate) { throw new ArgumentNullException(nameof(adjustableDate)); } // handle BusinessDatConventionEnum is NONE as a special case, since there might be no business centers provided. // if ((null == adjustableDate.dateAdjustments) || (BusinessDayConventionEnum.NONE == adjustableDate.dateAdjustments.businessDayConvention)) { return(adjustableDate.unadjustedDate.Value); } IBusinessCalendar businessCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, adjustableDate.dateAdjustments.businessCenters, nameSpace); DateTime result = businessCalendar.Roll(adjustableDate.unadjustedDate.Value, adjustableDate.dateAdjustments.businessDayConvention); return(result); }
/// <summary> /// /// </summary> /// <param name="logger"></param> /// <param name="cache"></param> /// <param name="nameSpace"></param> /// <param name="fixingCalendar"></param> /// <param name="paymentCalendar"></param> /// <param name="capFloorLeg"></param> /// <param name="spreadSchedule"></param> /// <param name="capOrFloorSchedule"></param> /// <param name="notionalSchedule"></param> /// <param name="marketEnvironment"></param> /// <param name="valuationDate"></param> /// <returns></returns> public static CapFloor GenerateDefinitionCashflowsAmounts(ILogger logger, ICoreCache cache, String nameSpace, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, CapFloorLegParametersRange capFloorLeg, Schedule spreadSchedule, Schedule capOrFloorSchedule, NonNegativeAmountSchedule notionalSchedule, ISwapLegEnvironment marketEnvironment, DateTime valuationDate) { CapFloor capFloor = GenerateDefinitionCashflows(logger, cache, nameSpace, fixingCalendar, paymentCalendar, capFloorLeg, spreadSchedule, capOrFloorSchedule, notionalSchedule); IRateCurve payStreamDiscountingCurve = marketEnvironment.GetDiscountRateCurve(); IRateCurve payStreamForecastCurve = marketEnvironment.GetForecastRateCurve(); FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(capFloor.capFloorStream, payStreamForecastCurve, payStreamDiscountingCurve, valuationDate); return(capFloor); }
/// <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); }
private static void UpdateCashflowsWithAmounts(ILogger logger, ICoreCache cache, String nameSpace, InterestRateStream stream, CapFloorLegParametersRange_Old legParametersRange, ValuationRange valuationRange) { // Get a forecast curve // IRateCurve forecastCurve = null; if (!String.IsNullOrEmpty(legParametersRange.ForecastCurve) && legParametersRange.ForecastCurve.ToLower() != "none") { forecastCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.ForecastCurve); } // Get a discount curve // var discountCurve = CurveLoader.LoadInterestRateCurve(logger, cache, nameSpace, legParametersRange.DiscountCurve); FixedAndFloatingRateStreamCashflowGenerator.UpdateCashflowsAmounts(stream, forecastCurve, discountCurve, valuationRange.ValuationDate); }
/// <summary> /// Moving to the new algorithm name! /// </summary> /// <param name="logger"></param> /// <param name="targetClient"></param> /// <param name="nameSpace"></param> public static void LoadPricingStructureAlgorithm(ILogger logger, ICoreCache targetClient, string nameSpace) { string xml = GetXml("FpML.V5r10.ConfigData.Config.PricingStructureAlgorithms.xml"); var pricingStructureTypes = XmlSerializerHelper.DeserializeFromString <PricingStructureTypes>(xml); //ItemInfo itemInfo = StandardConfigProps("PricingStructureAlgorithms", null); //targetClient.SaveObject<PricingStructureTypes>(pricingStructureTypes, itemInfo.ItemName, itemInfo.ItemProps); //logger.LogDebug("Loaded pricing structure types."); foreach (var pst in pricingStructureTypes.PricingStructureType) { foreach (var algo in pst.Algorithms) { var itemInfo = StandardConfigProps("Algorithm", pst.id + "." + algo.id, nameSpace); targetClient.SaveObject(algo, itemInfo.ItemName, itemInfo.ItemProps); logger.LogDebug("Loaded Algorithm: {0}", itemInfo.ItemName); } } }
public List <DetailedCashflowRangeItem> GetDetailedCashflowsWithNotionalSchedule( ILogger logger, ICoreCache cache, String nameSpace, IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, SwapLegParametersRange_Old legParametersRange, List <DateTimeDoubleRangeItem> notionalValueItems, ValuationRange valuationRange) { var tempList = notionalValueItems.Select(item => new Pair <DateTime, decimal>(item.DateTime, Convert.ToDecimal(item.Value))).ToList(); NonNegativeSchedule notionalScheduleFpML = NonNegativeScheduleHelper.Create(tempList); Currency currency = CurrencyHelper.Parse(legParametersRange.Currency); NonNegativeAmountSchedule amountSchedule = NonNegativeAmountScheduleHelper.Create(notionalScheduleFpML, currency); InterestRateStream interestRateStream = GetCashflowsScheduleWithNotionalSchedule(fixingCalendar, paymentCalendar, legParametersRange, amountSchedule); UpdateCashflowsWithAmounts(logger, cache, nameSpace, interestRateStream, legParametersRange, valuationRange); var list = new List <DetailedCashflowRangeItem>(); //int periodNumber = 1; foreach (PaymentCalculationPeriod paymentCalculationPeriod in interestRateStream.cashflows.paymentCalculationPeriod) { var detailedCashflowRangeItem = new DetailedCashflowRangeItem(); list.Add(detailedCashflowRangeItem); detailedCashflowRangeItem.PaymentDate = paymentCalculationPeriod.adjustedPaymentDate; detailedCashflowRangeItem.StartDate = PaymentCalculationPeriodHelper.GetCalculationPeriodStartDate(paymentCalculationPeriod); detailedCashflowRangeItem.EndDate = PaymentCalculationPeriodHelper.GetCalculationPeriodEndDate(paymentCalculationPeriod); //detailedCashflowRangeItem.NumberOfDays = PaymentCalculationPeriodHelper.GetNumberOfDays(paymentCalculationPeriod); //detailedCashflowRangeItem.FutureValue = MoneyHelper.ToDouble(paymentCalculationPeriod.forecastPaymentAmount); //detailedCashflowRangeItem.PresentValue = MoneyHelper.ToDouble(paymentCalculationPeriod.presentValueAmount); //detailedCashflowRangeItem.DiscountFactor = (double)paymentCalculationPeriod.discountFactor; detailedCashflowRangeItem.NotionalAmount = (double)PaymentCalculationPeriodHelper.GetNotionalAmount(paymentCalculationPeriod); detailedCashflowRangeItem.CouponType = GetCouponType(paymentCalculationPeriod); detailedCashflowRangeItem.Rate = (double)PaymentCalculationPeriodHelper.GetRate(paymentCalculationPeriod); // If floating rate - retrieve the spread. // if (legParametersRange.IsFloatingLegType()) { detailedCashflowRangeItem.Spread = (double)PaymentCalculationPeriodHelper.GetSpread(paymentCalculationPeriod); } } return(list); }
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> /// </summary> /// <param name="cache"></param> /// <param name="interestRateStream"></param> /// <param name="listAdjustedResetDates"></param> /// <param name="businessCalendar"></param> /// <param name="nameSpace"></param> /// <returns></returns> /// <exception cref="NotSupportedException"></exception> public static List <DateTime> GetAdjustedFixingDates(ICoreCache cache, InterestRateStream interestRateStream, List <DateTime> listAdjustedResetDates, IBusinessCalendar businessCalendar, string nameSpace) { var result = new List <DateTime>(); RelativeDateOffset fixingDatesOffset = interestRateStream.resetDates.fixingDates; int numberOfDays = int.Parse(fixingDatesOffset.periodMultiplier); // Only NON-POSITIVE offset expressed in BUSINESS DAYS is supported. // if (!(fixingDatesOffset.dayType == DayTypeEnum.Business & fixingDatesOffset.period == PeriodEnum.D & numberOfDays <= 0)) { string exceptionMessage = $"[{fixingDatesOffset.dayType} {fixingDatesOffset.period} {numberOfDays} days] fixing day offset is not supported."; throw new NotSupportedException(exceptionMessage); } var businessDayAdjustments = new BusinessDayAdjustments { businessCenters = fixingDatesOffset.businessCenters, businessDayConvention = fixingDatesOffset.businessDayConvention }; if (businessCalendar == null) { businessCalendar = BusinessCenterHelper.ToBusinessCalendar(cache, businessDayAdjustments.businessCenters, nameSpace); } foreach (DateTime adjustedResetDate in listAdjustedResetDates) { int offsetInBusinessDays = numberOfDays; DateTime adjustedFixingDate = adjustedResetDate; while (offsetInBusinessDays++ < 0) { // Adjust fixing date for one days back. // do { adjustedFixingDate = adjustedFixingDate.AddDays(-1); } while (!businessCalendar.IsBusinessDay(adjustedFixingDate)); // adjustedFixingDate has been adjusted for 1 BUSINESS DAY } result.Add(adjustedFixingDate); } return(result); }
private static void LoadFPMLTrades( ILogger logger, ICoreCache client, Assembly assembly, string sourceSystem) { logger.LogDebug("Loading FPML trades..."); Dictionary <string, string> chosenFiles = ResourceHelper.GetResources(assembly, ResourcePath + "." + sourceSystem, "xml"); if (chosenFiles.Count == 0) { throw new InvalidOperationException(String.Format("No trades found!")); } // load gwml-to-fpml mappings //EnumMaps enumMaps = client.LoadObject<EnumMaps>("Orion.Configuration.GwmlEnumMaps"); //GwmlFpmlEnumMap gwmlFpmlEnumMap = new GwmlFpmlEnumMap(enumMaps); foreach (KeyValuePair <string, string> file in chosenFiles) { string fpmlText = file.Value; // convert gwml //var fpmlDoc = XmlSerializerHelper.DeserializeFromString<DataDocument>(fpmlText); var tradeConfirmed = XmlSerializerHelper.DeserializeFromString <RequestConfirmation>(fpmlText); var trade = tradeConfirmed.trade; //Converter imp = new Converter(gwmlFpmlEnumMap); var tradeProps = new NamedValueSet(); tradeProps.Set(TradeProp.AsAtDate, DateTime.Today); tradeProps.Set(TradeProp.TradeSource, sourceSystem); // Document fpmlDoc = imp.ToFpml(gwmlDoc, tradeProps); // get trade properties //Trade trade = (Trade)(((DataDocument)fpmlDoc).Items[0]); ProductTypeSimpleEnum productType = ProductTypeSimpleScheme.ParseEnumString(trade.Item.Items[0].ToString());//TODO fix this DateTime tradeDate = trade.tradeHeader.tradeDate.Value; // now we can set the actual item name correctly string fpmlTradeItemName = $"{sourceSystem}.Trade.{productType}.{trade.id}"; //gwmlDocItemName = String.Format("{0}.GWML.{1}.{2}", sourceSystem, productType, trade.id); tradeProps.Set(TradeProp.TradeDate, tradeDate); tradeProps.Set(TradeProp.TradeId, trade.id); tradeProps.Set(TradeProp.ProductType, ProductTypeSimpleScheme.GetEnumString(productType)); tradeProps.Set(TradeProp.TradeState, TradeState.Verified.ToString()); client.SaveObject(trade, fpmlTradeItemName, tradeProps, false, TimeSpan.FromDays(30)); } // foreach file logger.LogDebug("Loaded {0} FPML trades.", chosenFiles.Count); }