private async Task populateDates(CarbonClient cc_)
{
var yesterday = await cc_.RollDateAsync(
date: DateTime.Today.ToNodaLocalDate(),
count: -1,
unit: Symmetry.Carbon.Model.DateUnit.Bd,
convention: Symmetry.Carbon.Model.BusinessDayConvention.Following,
calendar: Market.HolidayCode());
var spotSettle = await cc_.RollDateAsync(
date: DateTime.Today.ToNodaLocalDate(),
count: Market.DaysToSpot(),
unit: Symmetry.Carbon.Model.DateUnit.Bd,
convention: Symmetry.Carbon.Model.BusinessDayConvention.Following,
calendar: Market.HolidayCode());
var yesterdaySettle = await cc_.RollDateAsync(
date: yesterday,
count: Market.DaysToSpot(),
unit: Symmetry.Carbon.Model.DateUnit.Bd,
convention: Symmetry.Carbon.Model.BusinessDayConvention.Following,
calendar: Market.HolidayCode());
Today = new AsOfAndSpotSettle(DateTime.Today, spotSettle.ToDateTime());
Yesterday = new AsOfAndSpotSettle(yesterday.ToDateTime(), yesterdaySettle.ToDateTime());
}
public async Task Populate(CarbonClient cc_, OrderOverrides orderOv_)
{
if (m_source == null) return;
var dict = new Dictionary<string, LiveExposurePnlMulti>();
foreach (var item in m_source.InnerList)
{
var subItem = item.PnlName.Contains("#") ? item.PnlName.Split('#')[0] : item.PnlName;
if (!dict.ContainsKey(subItem))
{
var newItem = new LiveExposurePnlMulti(subItem) {DisplaySortNumber = await AssetOrder.GetOrder(subItem, cc_)};
if (orderOv_ != null && orderOv_.HasOverrides)
{
newItem.DisplaySortNumber = orderOv_.GetSortOrder(Helper.StripBbgEndings(item.PnlName));
}
dict.Add(subItem, newItem);
}
dict[subItem].Add(item);
}
var items = new List<LiveExposurePnlMulti>(dict.Values);
m_items.AddRange(items.OrderBy(x => x.DisplaySortNumber));
for (int i = 0; i < m_items.Count; ++i)
m_items[i].Index = i;
}
private async Task initiate(CarbonClient cc_, BondMeasures listenToThis_)
{
m_fcsCurve = await IRCurveImpl.Get(SwapCurve.GetForecastCurve(), DateContext, cc_);
// if we're doing calcs on the forwards, then don't need to listen to the curve directly
// as the forward price will be updated as a result of a change in curve and will trickle
// through to us as a price update
if (SettleDate == DateContext.SpotSettle)
m_fcsCurveDisp = m_fcsCurve.GetMonitor()/*.Throttle(TimeSpan.FromSeconds(10),Scheduler.Default)*/.Subscribe(handleFcstCurveUpdate);
if (SwapCurve.GetForecastCurve() == SwapCurve.GetDiscountCurve())
{
m_disCurve = m_fcsCurve;
}
else
{
m_disCurve = await IRCurveImpl.Get(SwapCurve.GetForecastCurve(), DateContext, cc_);
if (SettleDate == DateContext.SpotSettle)
m_disCurveDisp = m_disCurve.GetMonitor()/*.Throttle(TimeSpan.FromSeconds(10), Scheduler.Default)*/.Subscribe(handleDiscCurveUpdate);
}
//
var flds = new[] { BondMeasure.Price, BondMeasure.Yield };
Array.ForEach(flds, fld =>
{
var d = listenToThis_.GetValue(fld);
if (d.HasValue)
m_measures.SetValue(fld, d.Value);
});
calcMMS();
calcZSpread();
}
public async Task GoSave(SI.Data.EventDef event_, CarbonClient cc_, bool completeReSave_=false)
{
var dates = getDates(event_);
if (dates == null || dates.Count() == 0)
{
Logger.Debug(string.Format("Could not retrieve dates for {0}", event_), typeof(DateGetterBase));
return;
}
var eventCurrentDates = await event_.GetEvents(TZ.GMT,cc_);
// if doint a complete resave then need to load all, else work from the last point saved
var earliestDate = completeReSave_ || eventCurrentDates == null || eventCurrentDates.Length == 0
? _START_DATE
: eventCurrentDates.Last().AddMinutes(1d);
int updateCount = 0;
// whack in insert statements
foreach (var date in dates.Where(x => x > earliestDate))
{
updateCount += 1;
await event_.AddInGMTDateToLocalCache(date, cc_);
}
if (updateCount>0)
{
Logger.Debug(string.Format("About to save {0} dates for eventID:{1}", updateCount, event_), typeof(DateGetterBase));
await event_.WriteGMTEventsDatesToCarbon(cc_);
//Logger.Debug(string.Format("...{0}", success), typeof(DateGetterBase));
}
}
public Tuple<DateTime, string>[] GetAllEventsInRange(CarbonClient cc_, DateTime start, DateTime end)
{
var eventHandlers = Singleton<EventDefs>.Instance;
var eventCodes = new HashSet<Tuple<DateTime, string>>();
//Parallel.ForEach(eventHandlers, eh =>
//{
// var dates = eh.GetEvents(TZ.LN, cc_).Result;
// if (dates != null && dates.Any(d => d >= start && d <= end))
// eventCodes.Add(eh.EventCode);
//});
eventHandlers.ForEach(eh =>
{
var dates = eh.GetEvents(TZ.LN, cc_).Result;
if (dates != null && dates.Any(d => d >= start && d <= end))
{
var date = dates.Last(d => d <= end);
eh.Date = date;
eventCodes.Add(new Tuple<DateTime, string>(dates.Last(d => d <= end), eh.EventCode));
}
else if (dates != null && dates.Any())
{
DateTime date;
date = dates.FirstOrDefault(d => d >= DateTime.Today);
if (date == default(DateTime))
date = dates.Last();
eh.Date = date;
}
});
return eventCodes.ToArray();
}
public DateTime[] GetEventDates(string eventCode, CarbonClient cc_)
{
var eventHandler = Singleton<EventDefs>.Instance.FirstOrDefault(e => e.EventCode == eventCode);
if(eventHandler != null)
return eventHandler.GetEvents(TZ.LN, cc_).Result;
return null;
}
public async Task PopulateData(CarbonClient cc_)
{
var data = await cc_.GetStaticDataAsync(identifier: Identifier);
if (data == null || data.Count == 0) return;
foreach (var kvp in data[0].Properties)
{
switch (kvp.Key)
{
case "desc":
Description = kvp.Value.AsString();
break;
case "firstTradeDt":
FirstTrade = DateTime.ParseExact(kvp.Value.AsString(), "yyyyMMdd", CultureInfo.InvariantCulture);
break;
case "lastTradeDt":
LastTrade = DateTime.ParseExact(kvp.Value.AsString(), "yyyyMMdd", CultureInfo.InvariantCulture);
break;
case "firstNoticeDt":
FirstNotice = DateTime.ParseExact(kvp.Value.AsString(), "yyyyMMdd", CultureInfo.InvariantCulture);
break;
case "expirationDt":
Expiration = DateTime.ParseExact(kvp.Value.AsString(), "yyyyMMdd", CultureInfo.InvariantCulture);
break;
case "lastDeliveryDt":
LastDelivery = DateTime.ParseExact(kvp.Value.AsString(), "yyyyMMdd", CultureInfo.InvariantCulture);
break;
}
}
}
public static async Task<DatedDataCollectionGen<double>> Get(string name_, CarbonClient cc_, bool force_ = false)
{
if (_cache.ContainsKey(name_) && !force_)
return _cache[name_];
try
{
var con = await DataFrameHelper.GetDataFrameByRow(
name_: string.Format("ssys.trs.{0}",name_),
keyExtractor_: x => (DateTime) x,
valueExtractor_: (dict, vals) => Convert.ToDouble(vals[0]),
cc_: cc_);
var ddc = new DatedDataCollectionGen<double>(con.Keys.ToArray(), con.GetColumnValues(0));
_cache[name_] = ddc;
return ddc;
}
catch (Exception ex_)
{
_cache[name_] = null;
Logger.Error(string.Format("Error getting timeseries for [{0}]", name_), typeof (TimeSeries), ex_);
return null;
}
}
public async Task Create(CarbonClient cc_)
{
await interEventsPickOneSide1.Create(cc_);
await interEventsPickOneSide2.Create(cc_);
interEventsPickOneSide1.SelectedChanged += (x, y) =>
{
m_boundList.Clear();
};
interEventsPickOneSide2.SelectedChanged += (x, y) =>
{
m_boundList.Clear();
};
boundInfraGrid1.Bind(m_boundList);
eventPreselectionControlYearQuarter1.Create();
eventPreselectionControlYearQuarter1.PreselectionChanged += (x, y) =>
{
preselect();
};
}
public static void ClearUp()
{
if (_persistedInstance == null) return;
_persistedInstance.Dispose();
_persistedInstance = null;
}
public async Task<double[]> CalcContToRisk(string[] exposureNames_, double[] exposureValues_, CarbonClient cc_)
{
// get indexes for instruments in covariance
var indexes = new Tuple<int, bool>[exposureNames_.Length];
for (int i = 0; i < indexes.Length; ++i)
indexes[i] = await FindIndexOfInstrument(exposureNames_[i], cc_);
// translate up the exposures into same dimensions as covariance
var exposuresInCovarianceDimensions = new double[Keys.Count];
for (int i = 0; i < indexes.Length; ++i)
{
if (indexes[i] == null) continue;
exposuresInCovarianceDimensions[indexes[i].Item1] = (indexes[i].Item2 ? -1d : 1d) * exposureValues_[i];
}
// calculate contributions to risk
var contToRisk = GetContToVar(exposuresInCovarianceDimensions);
// translate back into porfolio dimensions
var riskInPortfolioDimensions = new double[exposureValues_.Length];
for (int i = 0; i < riskInPortfolioDimensions.Length; ++i)
{
if (indexes[i] == null) continue;
riskInPortfolioDimensions[i] = contToRisk[indexes[i].Item1];
}
return riskInPortfolioDimensions;
}
public async Task<ConstructGenGen<string, double>> GetAsConstruct(DateTime date_, CarbonClient cc_)
{
var moniker = string.Format("ssys.dashboard.covariance_matrix.15.2.{0}", date_.ToString("yyyyMMdd"));
ConstructGenGen<string, double> con;
try
{
con = await DataFrameHelper.GetDataFrameCellByCell(
name_: moniker,
keyExtractor_: (x) => (string)x,
valueExtractor_: (val) =>
{
double ret = 0d;
if (val is IConvertible)
ret = Convert.ToDouble(val) * 252d;
return ret;
},
cc_: cc_);
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error getting covariance for date [{0}]", date_.ToString("dd-MMM-yyyy")),
typeof(Covariances), ex_);
con = null;
}
return con;
}
public async Task Go(bool force_ = false, bool backFillFromTStoo_=false)
{
registerAllMongoDocTypes();
using (var cc = new CarbonClient("PRD"))
{
{
// get sets of calendar combinations and gets distinct set
var tups = (from swapCurve in SwapCurveDefinitions.AllDefinitions()
select Tuple.Create(swapCurve.OTHolidayCode, swapCurve.DaysToSpot))
.FindDistinct(x => string.Format("{0}_{1}", x.Item1, x.Item2));
// update for each distinct sets
foreach (var tup in tups)
{
// update records of tenor dates
await DatesWorker.DWInstance().GoAll(
otHolidayCode_: tup.Item1,
daysToSpot_: tup.Item2,
cc_: cc,
force_: force_);
}
}
// update records of discount factors
{
// first, need the distinct set of component curves
// select out all unique required discount factors
var tups = (from swapCurve in SwapCurveDefinitions.AllDefinitions()
from curve in swapCurve.AllCurves
select Tuple.Create(swapCurve.OTHolidayCode, swapCurve.DaysToSpot, curve))
.FindDistinct(x => string.Format("{0}_{1}_{2}", x.Item1, x.Item2, x.Item3.CarbonCurveName))
.ToList();
// now operate on all the sets
foreach (var tup in tups)
{
await DFsWorker.DFInstance().GoAll(tup.Item1, tup.Item2, tup.Item3, cc);
if (backFillFromTStoo_ && !string.IsNullOrEmpty(tup.Item3.SymmetryTSName))
await DFsWorker.DFInstance().BackFillFromSymmetryTS(tup.Item1, tup.Item2, tup.Item3);
}
}
// update constant maturity futures
{
CMFuturesWorker.FutInstance().GoAllSets();
}
// update all stats
{
StatsGenerationWorker.GetInstance().Go();
}
await PersistSetsForDeriveddataWorker.Go(cc);
}
}
public static async Task<IReadOnlyList<InstrumentETF>> GetAll(CarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null ? null : new ReadOnlyCollection<InstrumentETF>(_list);
}
public async Task<CovarianceWrapper> Get(DateTime date_, CarbonClient cc_)
{
if (m_cache.ContainsKey(date_))
return m_cache[date_];
var con = await GetAsConstruct(date_, cc_);
if (con == null) return null;
try
{
var asDbl = con.GetAllValues();
if (asDbl.GetLength(0) != asDbl.GetLength(1))
{
throw new Exception("Covariance matrix is not square!");
}
var cov = new CovarianceWrapper(asDbl, con.ColumnHeadings);
m_cache[date_] = cov;
return cov;
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error processing covariance for date [{0}]", date_.ToString("dd-MMM-yyyy")),
typeof(Covariances), ex_);
}
return null;
}
public async Task<IEnumerable<CarbonFuture>> GetContracts(CarbonClient cc_)
{
if (m_contracts != null) return m_contracts;
await populateData(cc_);
return m_contracts;
}
public async static Task<FXInstrument> GetByCcyCode(string ccyCode_, CarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null
? null
: _list.FirstOrDefault(x => String.Compare(ccyCode_, x.Ccy, StringComparison.OrdinalIgnoreCase) == 0);
}
//----------------------------------------------------------------------------------------
public static CarbonClient GetCarbonClient()
//----------------------------------------------------------------------------------------
{
if (carbonClient == null)
{
carbonClient = new CarbonClient("PRD");
}
return carbonClient;
}
public HistoricalUnAllocatedPnl(CarbonClient cc_, PerfRow row_)
: base(
cc_: cc_,
text_: string.Format("{0} unallocated pnl", row_.Underlying.RootName),
row_: row_)
{
Image = DashboardResources.moneyBlack;
DisplayStyle = ToolStripItemDisplayStyle.ImageAndText;
}
/// <summary>
/// Find the first ccy with the given name.
/// </summary>
/// <param name="ccyName_">e.g. 'CADUSD' / 'AUDUSD' / 'USDMXN' / 'MXNUSD'</param>
/// <param name="cc_"></param>
/// <returns></returns>
public static async Task<InstrumentFX> GetByName(string ccyName_, CarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null
? null
: _list.FirstOrDefault(x => string.Compare(ccyName_, x.Name, StringComparison.OrdinalIgnoreCase) == 0);
}
public async static Task<FutureInstrument> GetByBbgTicker(string bbgTicker_, CarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null
? null
: _list.FirstOrDefault(x => String.Compare(bbgTicker_, x.Bbgticker, StringComparison.OrdinalIgnoreCase) == 0);
}
public virtual async Task<DateTime[]> GetEvents(TZ tz_, CarbonClient cc_)
{
if (_cache.ContainsKey(tz_))
return _cache[tz_];
_cache[tz_] = await getEventInner(tz_, cc_);
return _cache.ContainsKey(tz_) ? _cache[tz_] : null;
}
public static async Task<DatedDataCollectionGen<double>> Get(string exposureName_, CarbonClient cc_)
{
if (m_list == null || m_list.Count == 0)
await populateKnown(cc_);
if (m_list.ContainsKey(exposureName_))
return m_list[exposureName_];
return null;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if(disposing)
{
CarbonClient = null;
Row = null;
}
}
public async Task<BondMeasureCalcSpreadsOverCurve> CreateFullMeasuresCalculator(SwapCurve curve_, CarbonClient cc_)
{
return await BondMeasureCalcSpreadsOverCurve.Create(
bond_: m_bond,
swapcurve_: curve_,
updateThis_: new BondMeasures(m_bond),
listenToThis_: m_measures,
cc_: cc_,
settleDate_: SettleDate,
dateContext_: DateContext);
}
protected ContextMenuItemBase(
CarbonClient cc_,
string text_,
PerfRow row_)
{
Text = text_;
Row = row_;
CarbonClient = cc_;
Click += handleClick;
}
public static async Task<InstrumentFuture> GetByBbgTicker(string bbgTicker_, CarbonClient cc_)
{
if (_list == null)
await populate(cc_);
var trimmedTicker = bbgTicker_.Trim();
return _list == null
? null
: _list.FirstOrDefault(x => String.Compare(trimmedTicker, x.Bbgticker.Trim(), StringComparison.OrdinalIgnoreCase) == 0);
}
private static async Task populateKnown(CarbonClient cc_)
{
var knownMonikers = AssetClassMonikerRoots.Roots.Select(x => string.Format("{0}.fills", x));
m_list = new Dictionary<string, DatedDataCollectionGen<double>>();
foreach (var moniker in knownMonikers)
{
Logger.Info(string.Format("Loading up fills from document [{0}]...", moniker), typeof (Fills));
await populateMoniker(cc_, moniker);
}
}
public static async Task<DatedDataCollectionGen<double>> Get(string entry_, CarbonClient cc_)
{
if (m_list == null || m_list.Count == 0)
await populateKnown(cc_);
if (m_list.ContainsKey(entry_))
return m_list[entry_];
Logger.Error(string.Format("No fills found for given security: [{0}]", entry_), typeof(Fills));
return null;
}
public async Task<ITRInstrument> TRInstrument(CarbonClient cc_)
{
if (m_trInstrument != null)
return m_trInstrument.Value;
var name = Name.Contains("#") ? Name.Split('#')[0] : Name;
// try futures first
{
var future = await InstrumentList_Futures.GetByBbgTicker(name, cc_);
if (future != null)
{
m_trInstrument = new TriedObject<ITRInstrument>(future);
return m_trInstrument.Value;
}
}
// then fx
{
var fx = await InstrumentList_FX.GetByName(name, cc_);
// more than likely we'll have a 3 character currency code coming from fx portfolios.
// this implies a position in CCY vs USD, so try getting that...
if (fx == null && name.Length == 3)
{
fx = await InstrumentList_FX.GetByName(string.Format("{0}USD", name), cc_);
}
if (fx != null)
{
m_trInstrument = new TriedObject<ITRInstrument>(fx);
return m_trInstrument.Value;
}
}
// swaps
{
var swap = await InstrumentList_Swaps.GetByBbgTicker(name, cc_);
if (swap != null)
{
m_trInstrument = new TriedObject<ITRInstrument>(swap);
return m_trInstrument.Value;
}
}
Logger.Info(string.Format("Cannot find equivalent TRS object for [{0}]", Name), typeof(SecMasterEntry));
m_trInstrument = new TriedObject<ITRInstrument>();
return m_trInstrument.Value;
}
