diff --git a/src/client/spark/AW2/VolSurfaceDisplayModel.cs b/src/client/spark/AW2/VolSurfaceDisplayModel.cs new file mode 100644 index 000000000..002f88a05 --- /dev/null +++ b/src/client/spark/AW2/VolSurfaceDisplayModel.cs @@ -0,0 +1,604 @@ +using bts.api; + +using mbts; +using mbts.analytics; + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using mbts.ui.controls; +using bts.utils; +using System.Reactive.Linq; +using System.Collections; + +namespace mbts.spark { + public class VolSurfaceDisplayModel : IDisposable { + public enum DisplayModelState { + /// Start state, as soon as the first + /// server state is received, it gets + /// out from here to Idle + WaitingForCommittedState = 0, + /// When there is nothing to commit/revert + /// (ie no local changes) + Idle, + /// When the UI makes a calculation request + /// (either through a data change, action + /// or settings change) + WaitingForCalcResponse, + /// Once the calculation response is received + /// it goes to this (from ResponseWaiting) + ResponseReady + } + + public class DisplayModelData : ICloneable { + private VolSurfaceDisplayModel _model; + public VolSurfaceOutput vs_output = null; + public VolSurfaceDisplayGlobalGrid global_grid = null; + public VolSurfaceDisplayGrid exp_grid = null; + public IDictionary exp_graph_map = null; + + public DisplayModelData(VolSurfaceDisplayModel model) { _model = model; } + + public object Clone() { + DisplayModelData rv = new DisplayModelData(_model); + rv.vs_output = vs_output != null ? vs_output.Clone() as VolSurfaceOutput : null; + VolSurfaceUIAdapter.copy_output_to_ui(vs_output, _model._grid_settings, out rv.exp_grid, out rv.global_grid, out rv.exp_graph_map); + return rv; + } + } + + private readonly int _vs_id; + private readonly IBus _bus; + private readonly ITag _in_bb_committed_output_tag; + private readonly ITag _in_bb_calculation_response_tag; + private readonly ITag>> _in_bb_impl_vol_tag; + private readonly ITag> _in_bb_state_list_tag; + private readonly bool _publish_lifetime; + + internal void global_vol_shift(object is_up) { + throw new NotImplementedException(); + } + + private readonly VolSurfaceDisplayGrid _empty_grid = new VolSurfaceDisplayGrid(new VolSurfaceDisplayGridExpiration[] { }, + new VolSurfaceDisplayGridColumn[] { }, + new Dictionary>()); + private DisplayModelState _state = DisplayModelState.WaitingForCommittedState; + private DisplayModelData _committed_data, _candidate_data; + private int _request_version_no = 0; + private IDictionary> _impl_vol_map = new Dictionary>(); + private IEnumerable _input_snapshot_list = new List(); + + #region Events + public event Action on_committed_grid_change, on_candidate_grid_change = () => { }; + public event Action on_graph_change; + public event Action on_dirty_change; + #endregion + + public VolSurfaceDisplayModel(int vs_id, IBus bus, bool publish_lifetime = false) { + _vs_id = vs_id; + _bus = bus; + _publish_lifetime = publish_lifetime; + _committed_data = new DisplayModelData(this); + _candidate_data = new DisplayModelData(this); + _in_bb_committed_output_tag = SparkTags.VolSurfaceCommittedOutputTag(vs_id); + _in_bb_calculation_response_tag = SparkTags.VolSurfaceCalculationResponseTag(vs_id); + _in_bb_impl_vol_tag = SparkTags.VolSurfaceMarketImpliedVolTag(vs_id); + _in_bb_state_list_tag = SparkTags.VolSurfaceInputSnapshotListTag(vs_id); + _bus.post(SparkTags.VolSurfaceActivationTag(vs_id), true); + + _subscriptions = Disposable.Create( + _bus.subscribe(_in_bb_committed_output_tag).OnDispatcher().Subscribe(_on_server_update), + _bus.subscribe(_in_bb_calculation_response_tag).OnDispatcher().Subscribe(_on_calculation_response), + _bus.subscribe(_in_bb_impl_vol_tag).OnDispatcher().Subscribe(_on_impl_vol_update), + _bus.subscribe(_in_bb_state_list_tag).OnDispatcher().Subscribe(_on_state_list_update)); + if (_publish_lifetime) + _bus.post(SparkTags.VolSurfaceActiveUITag(vs_id), true); + } + + + private IDisposable _subscriptions; + + #region Expiration Grid Getters/Setters + + public VolSurfaceDisplayGrid get_committed_grid() { return _committed_data.exp_grid != null ? _committed_data.exp_grid.Clone() as VolSurfaceDisplayGrid : _empty_grid; } + + public VolSurfaceDisplayGrid get_active_grid() { return is_dirty ? (_candidate_data.exp_grid != null ? _candidate_data.exp_grid.Clone() as VolSurfaceDisplayGrid : _empty_grid) : get_committed_grid(); } + + public void set_candidate_grid(VolSurfaceDisplayGrid exp_grid) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + _candidate_data.exp_grid = exp_grid.Clone() as VolSurfaceDisplayGrid; + DisplayModelData curr_data = _get_current_data(); + VolSurfaceInput vs_inp = VolSurfaceUIAdapter.copy_ui_to_input(_candidate_data.exp_grid, curr_data.vs_output.volsurface_input.surface_settings, _grid_settings); + vs_inp.surface_parameters.vol_time = curr_data.vs_output.volsurface_input.surface_parameters.vol_time; + _copy_time_parameters(curr_data.vs_output.volsurface_input, ref vs_inp); + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), + new VolSurfaceCalculationRequest(vs_inp, _request_version_no++)); + } else + _log_bad_transition(_state, "set candidate grid"); + } + + #endregion + + #region Globals + public VolSurfaceEnums.VolSurfaceTimeMode get_active_vol_time_mode() { + var curr_data = _get_current_data(); + if (curr_data != null) { + var ts = curr_data.vs_output.volsurface_input.surface_settings.core_settings.time_settings; + if (ts != null) return ts.time_mode; + } + return VolSurfaceEnums.VolSurfaceTimeMode.Manual; + } + public DateTime get_active_vol_time() { + DisplayModelData curr_data = _get_current_data(); + return (curr_data != null && curr_data.vs_output != null) ? curr_data.vs_output.get_vol_time() : DateTime.MinValue; + } + public DateTime get_committed_vol_time() { + return (_committed_data != null && _committed_data.vs_output != null) ? _committed_data.vs_output.volsurface_input.surface_parameters.vol_time : DateTime.MinValue; + } + public void set_candidate_vol_time(DateTime vol_time) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) { + VolSurfaceInput vs_input = VolSurfaceUtilityFunctions.clone_proto(curr_data.vs_output.volsurface_input); + vs_input.surface_parameters.vol_time = vol_time; + VolSurfaceCalculationRequest req = new VolSurfaceCalculationRequest(vs_input, _request_version_no++); + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), req); + } + } + } + /// + /// Gets the Auto Decay Points for this VolSurface. + /// + /// The AutoDecay Points for this VolSurface, or null if the VolSurfaceTimeMode (found in VolSurfaceSettings.core_settings.time_settings) is not set to AutoDecay. + public IEnumerable> get_active_time_decay_points() { + DisplayModelData curr_data = _get_current_data(); + if (curr_data == null || curr_data.vs_output == null) return null; + var ts = curr_data.vs_output.volsurface_input.surface_settings.core_settings.time_settings; + if (ts == null || ts.time_mode != VolSurfaceEnums.VolSurfaceTimeMode.AutoDecay) return null; + var tp = curr_data.vs_output.volsurface_input.surface_parameters.time_parameters; + return tp == null ? Enumerable.Empty>() : tp.auto_decay_points ?? Enumerable.Empty>(); + } + public void set_candidate_time_decay_parameters(IEnumerable> auto_decay_points) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) { + VolSurfaceInput vs_input = VolSurfaceUtilityFunctions.clone_proto(curr_data.vs_output.volsurface_input); + if (vs_input.surface_parameters.time_parameters == null) vs_input.surface_parameters.time_parameters = new VolSurfaceTimeParameters(); + vs_input.surface_parameters.time_parameters.auto_decay_points = auto_decay_points.ToList(); + VolSurfaceCalculationRequest req = new VolSurfaceCalculationRequest(vs_input, _request_version_no++); + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), req); + } + } + } + #endregion + + #region Settings + /// Will always be called from the UI when the wizard changes + /// a setting + public void set_candidate_settings(mbts.analytics.VolSurfaceSettings settings) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null && settings != null) { + VolSurfaceInput vs_input = VolSurfaceUtilityFunctions.clone_proto(curr_data.vs_output.volsurface_input); + vs_input.surface_settings = settings; + VolSurfaceCalculationRequest req = new VolSurfaceCalculationRequest(vs_input, _request_version_no++); + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), req); + } + } + } + + public VolSurfaceSettings get_active_settings() { + var curr_data = _get_current_data(); + return curr_data == null ? null : curr_data.vs_output.volsurface_input.surface_settings; + } + + private VolSurfaceMacroGridSettings _grid_settings = null; + public void publish_grid_settings(VolSurfaceMacroGridSettings settings) { + _grid_settings = settings; + _bus.post(SparkTags.VolSurfaceMacroGridSettingsTag(_vs_id), settings); + } + #endregion + + #region Graph Getters + + public IEnumerable get_ordered_expirations() { + VolSurfaceDisplayGrid current_grid = get_active_grid(); + return current_grid != null && current_grid.get_ordered_expirations() != null ? current_grid.get_ordered_expirations() : new List(); + } + + private readonly VolCurveDisplayGraph _empty_graph = new VolCurveDisplayGraph(new List>(), new List>(), new List>(), new Tuple(Double.NaN, Double.NaN), Double.NaN, Double.NaN); + public VolCurveDisplayGraph get_committed_exp_vol_graph(VolSurfaceDisplayGridExpiration exp) { + VolCurveDisplayGraph disp_graph = null; + return _committed_data.exp_graph_map != null && _committed_data.exp_graph_map.TryGetValue(exp, out disp_graph) ? disp_graph : _empty_graph; + } + + public IEnumerable> get_committed_volpath(VolSurfaceDisplayGridExpiration exp) { + if (_committed_data != null && _committed_data.vs_output != null) { + VolCurveOutput exp_out = _committed_data.vs_output[new VolSurfaceExpiration(exp.symbol, exp.expiration)]; + return VolSurfaceUtilityFunctions.get_vol_path_points(exp_out); + } else + return Enumerable.Empty>(); + } + + public IEnumerable> get_candidate_volpath(VolSurfaceDisplayGridExpiration exp) { + if (is_dirty && _candidate_data != null && _candidate_data.vs_output != null) { + VolCurveOutput exp_out = _candidate_data.vs_output[new VolSurfaceExpiration(exp.symbol, exp.expiration)]; + return VolSurfaceUtilityFunctions.get_vol_path_points(exp_out); + } else + return Enumerable.Empty>(); + } + + public VolCurveDisplayGraph get_candidate_exp_vol_graph(VolSurfaceDisplayGridExpiration exp) { + VolCurveDisplayGraph disp_graph = null; + return is_dirty && _candidate_data.exp_graph_map != null && _candidate_data.exp_graph_map.TryGetValue(exp, out disp_graph) ? disp_graph : _empty_graph; + } + + public Dictionary get_committed_term_structure_map() { + return _committed_data == null || _committed_data.vs_output == null ? new Dictionary() : _committed_data.vs_output.exp_output_map.ToDictionary(kv => kv.Key, kv => kv.Value.atm_vol); + } + + public Dictionary get_candidate_term_structure_map() { + return !is_dirty || _candidate_data == null || _candidate_data.vs_output == null ? new Dictionary() : _candidate_data.vs_output.exp_output_map.ToDictionary(kv => kv.Key, kv => kv.Value.atm_vol); + } + + public VolCurveMarketImpliedVolData get_market_market_implied_vols(VolSurfaceDisplayGridExpiration exp) { + Tuple rv = null; + return _impl_vol_map.TryGetValue(new VolSurfaceExpiration() { symbol = exp.symbol, expiration = exp.expiration }, out rv) ? rv.Item2 : null; + } + + public VolSurfaceExpiration get_market_implied_vol_source(VolSurfaceDisplayGridExpiration exp) { + Tuple rv = null; + return _impl_vol_map.TryGetValue(new VolSurfaceExpiration() { symbol = exp.symbol, expiration = exp.expiration }, out rv) ? rv.Item1 : null; + } + + #endregion + + #region Detail View + public void show_details() { + _bus.post(SparkTags.VolSurfaceLaunchTheoWindow, _vs_id); + } + #endregion + + #region State History + + public event Action on_previous_state_list_change = () => { }; + public IEnumerable get_previous_states() { + if (_input_snapshot_list != null) { + IEnumerable input_list = _input_snapshot_list.OrderBy(s => s.save_time_utc); + input_list = input_list.OrderBy(vss => vss.save_time_utc).Reverse(); + return input_list.Select(s => s.save_marker); + } else + return new string[] { }; + } + + public void load_previous_state(string state_name) { + //mbts.Logger.log(bts.log.Level.Info, bts.log.Subsystem.ui, String.Format("VolSurfaceDisplayModel load_previous_state called with state {0}", state_name)); + bts.Log.Ui.info(String.Format("VolSurfaceDisplayModel load_previous_state called with state {0}", state_name)); + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + bool succ = false; + VolSurfaceInputSnapshot vs_sn = _input_snapshot_list.ToList().Find(v => v.save_marker == state_name); + if (vs_sn != null) { + VolSurfaceInput vs_inp = VolSurfaceUtilityFunctions.deserialize_proto(vs_sn.data); + if (vs_inp != null) { + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), + new VolSurfaceCalculationRequest(vs_inp, _request_version_no++)); + succ = true; + } + } + if (!succ) + _bus.post(SparkTags.MessageDisplayTag, new MessageDisplayData("Load Vol Surface Error", ("Could not load previously saved Vol Surface"))); + } + } + + #endregion + + #region File operation + + /// Returns the bytes for the current Vol Surface + /// (ie candidate if dirty, else committed). + /// Returns null if there is no data + public byte[] get_current_state() { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null && curr_data.vs_output != null && curr_data.vs_output.volsurface_input != null) + return VolSurfaceUtilityFunctions.serialize_proto(curr_data.vs_output.volsurface_input); + else + return null; + } + + /// Sets the state that is passed in bytes form. Returns + /// true is state is set successfully + public bool set_state(byte[] file_data) { + VolSurfaceInput vs_input = VolSurfaceUtilityFunctions.deserialize_proto(file_data); + if (vs_input != null) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), + new VolSurfaceCalculationRequest(vs_input, _request_version_no++)); + return true; + } + } + return false; + } + + public bool csv_importing_enabled() { return true; } + + public void import_csv_file(string file_path) { + try { + System.IO.StreamReader reader = new System.IO.StreamReader(file_path); + string header = reader.ReadLine(); + string[] col_names = header.Split(',').Select(cn => cn.Trim()).ToArray(); + IDictionary file_col_map = new Dictionary(); + /// first 2 cols are always symbol and expiration + for (int i = 2; i < col_names.Length; i++) + file_col_map.Add(i, col_names[i]); + VolSurfaceDisplayGrid grid = get_active_grid().Clone() as VolSurfaceDisplayGrid; + while (!reader.EndOfStream) { + string line = reader.ReadLine(); + string[] data_items = line.Split(',').Select(cn => cn.Trim()).ToArray(); + if (data_items.Length != col_names.Length) + throw new ApplicationException("Data is not well formed"); + VolSurfaceDisplayGridExpiration grid_exp = new VolSurfaceDisplayGridExpiration(data_items[0], DateTime.Parse(data_items[1]), VolSurfaceEnums.VolSurfaceExpirationCalculationMethod.Master); + for (int i = 2; i < col_names.Length; i++) { + string col_name = file_col_map[i]; + string data_text = data_items[i]; + if (!String.IsNullOrEmpty(data_text)) + grid.set_grid_data_text(grid_exp, col_name, data_text); + } + } + set_candidate_grid(grid); + } catch (Exception ex) { + _bus.post(SparkTags.MessageDisplayTag, new MessageDisplayData("Import Error", ex.ToString(), false)); + } + } + + #endregion + + #region Syncing Slaves + + public void sync_slave_ref_forwards(VolSurfaceExpiration vs_exp) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null && curr_data.vs_output != null && curr_data.vs_output.volsurface_input != null) { + IEnumerable slave_exps = VolSurfaceUtilityFunctions.get_slave_expirations(curr_data.vs_output.volsurface_input); + _send_curve_action_request(slave_exps.ToDictionaryDupes(e => e, e => new VolCurveAction(VolCurveAction.ActionType.SyncSlaveRefFwds)), false, false); + } + } + + #endregion + + #region Blackboard response + private void _on_server_update(VolSurfaceOutput vs_output) { + if (vs_output != null) { + vs_output = vs_output.Clone() as VolSurfaceOutput; + if (_state == DisplayModelState.WaitingForCommittedState) { + //mbts.Logger.log(bts.log.Level.Info, bts.log.Subsystem.ui, String.Format("Received first committed update for vol surface id {0}", _vs_id)); + bts.Log.Ui.info(String.Format("Received first committed update for vol surface id {0}", _vs_id)); + _committed_data.vs_output = vs_output; + VolSurfaceUIAdapter.copy_output_to_ui(_committed_data.vs_output, _grid_settings, out _committed_data.exp_grid, out _committed_data.global_grid, out _committed_data.exp_graph_map); + _change_state(DisplayModelState.Idle); + if (on_committed_grid_change != null) + on_committed_grid_change(); + if (on_graph_change != null) + on_graph_change(); + } else if (_state == DisplayModelState.Idle || _state == DisplayModelState.WaitingForCalcResponse || _state == DisplayModelState.ResponseReady) { + //mbts.Logger.log(bts.log.Level.Diag, bts.log.Subsystem.ui, String.Format("Received committed update for vol surface id {0} state {1}", _vs_id, _state.ToString())); + bts.Log.Ui.diag(String.Format("Received committed update for vol surface id {0} state {1}", _vs_id, _state.ToString())); + _committed_data.vs_output = vs_output; + VolSurfaceUIAdapter.copy_output_to_ui(_committed_data.vs_output, _grid_settings, out _committed_data.exp_grid, out _committed_data.global_grid, out _committed_data.exp_graph_map); + if (on_committed_grid_change != null) + on_committed_grid_change(); + if (on_graph_change != null) + on_graph_change(); + } else + _log_bad_transition(_state, "On Committed State Update"); + } + } + + private void _on_calculation_response(VolSurfaceCalculationResponse data) { + if (_state == DisplayModelState.WaitingForCalcResponse || _state == DisplayModelState.ResponseReady) { + //Logger.log(bts.log.Level.Info, bts.log.Subsystem.ui, String.Format("Received calculation response for vol surface id {0} state {1}", _vs_id, _state.ToString())); + bts.Log.Ui.info(String.Format("Received calculation response for vol surface id {0} state {1}", _vs_id, _state.ToString())); + VolSurfaceCalculationResponse calc_response = (data).Clone() as VolSurfaceCalculationResponse; + _candidate_data.vs_output = calc_response.volsurface_calculation_output; + VolSurfaceUIAdapter.copy_output_to_ui(_candidate_data.vs_output, _grid_settings, out _candidate_data.exp_grid, out _candidate_data.global_grid, out _candidate_data.exp_graph_map); + if (_state == DisplayModelState.WaitingForCalcResponse) + _change_state(DisplayModelState.ResponseReady); + if (on_candidate_grid_change != null) + on_candidate_grid_change(); + if (on_graph_change != null) + on_graph_change(); + } + } + + private void _on_impl_vol_update(IDictionary> data) { + _impl_vol_map = data; + if (on_graph_change != null) + on_graph_change(); + } + + private void _on_state_list_update(IEnumerable data) { + _input_snapshot_list = new List(data); + if (on_previous_state_list_change != null) + on_previous_state_list_change(); + } + + #endregion + + #region Actions originating from the UI + public void put_rotation(IEnumerable exps, bool is_up, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) + _send_curve_operation_request(exps, curr_data.vs_output.volsurface_input.surface_settings.core_settings.put_rotation, is_up, cascade_up, cascade_down); + } + + public void call_rotation(IEnumerable exps, bool is_up, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) + _send_curve_operation_request(exps, curr_data.vs_output.volsurface_input.surface_settings.core_settings.call_rotation, is_up, cascade_up, cascade_down); + } + + public void full_rotation(IEnumerable exps, bool is_up, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) + _send_curve_operation_request(exps, curr_data.vs_output.volsurface_input.surface_settings.core_settings.full_rotation, is_up, cascade_up, cascade_down); + } + + public void strangle(IEnumerable exps, bool is_up, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) + _send_curve_operation_request(exps, curr_data.vs_output.volsurface_input.surface_settings.core_settings.strangle, is_up, cascade_up, cascade_down); + } + + public void atm_shift(IEnumerable exps, bool is_up, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + if (curr_data != null) + _send_curve_operation_request(exps, curr_data.vs_output.volsurface_input.surface_settings.core_settings.atm_shift, is_up, cascade_up, cascade_down); + } + + public void fit_to_market(IEnumerable exp_list, bool is_all_curve, bool is_live_market, + bool use_weighted_regression_fit, bool cascade_up, bool cascade_down) { + DisplayModelData curr_data = _get_current_data(); + IEnumerable vs_exps = exp_list.Select(i => i.ToVSExp()); + _send_curve_action_request(vs_exps.ToDictionary(e => e, + e => { + VolCurveMarketFitAction.ActionType action_type = is_all_curve ? VolCurveMarketFitAction.ActionType.FitWholeCurve : VolCurveMarketFitAction.ActionType.FitATM; + return new VolCurveAction(new VolCurveMarketFitAction(action_type, null, use_weighted_regression_fit)); + }), + cascade_up, cascade_down); + } + + public void rebuild(IEnumerable exp_list, bool cascade_up, bool cascade_down) { + _send_curve_action_request(exp_list.ToDictionary(e => e.ToVSExp(), e => new VolCurveAction(VolCurveAction.ActionType.Rebuild)), cascade_up, cascade_down); + } + + public void publish_new_grid_selection(string window_id, VolSurfaceDisplayGridExpiration selected_expiration, bool show_implied_vol_checked) { + _bus.post(SparkTags.VolSurfaceGridSelectionTag(_vs_id), new Tuple(selected_expiration, show_implied_vol_checked)); + } + + + public void set_impliedvol_market_side(VolSurfaceEnums.MarketSide market_side) { + _bus.post(SparkTags.VolSurfaceMarketImpliedVolSide(_vs_id), market_side); + } + + public void publish_ignore_implied_vol_settings(string window_id, bool ignore_implied_vol_settings) { + _bus.post(SparkTags.VolSurfaceIgnoreImpliedVolSettingsTag(_vs_id), ignore_implied_vol_settings); + } + + public void offset_slaves_atm(IEnumerable exps, double offset_dollars) { + // TODO + } + #endregion + + #region Commit/Revert + public void revert() { + if (_state == DisplayModelState.WaitingForCalcResponse || _state == DisplayModelState.ResponseReady) { + _candidate_data = _committed_data.Clone() as DisplayModelData; + _change_state(DisplayModelState.Idle); + on_candidate_grid_change(); + on_graph_change(); + } else + _log_bad_transition(_state, "revert"); + } + + public void commit() { + if (_state == DisplayModelState.ResponseReady) { + _bus.post(SparkTags.VolSurfaceCommitTag(_vs_id), _candidate_data.vs_output.volsurface_input); + _change_state(DisplayModelState.Idle); + } else + _log_bad_transition(_state, "commit"); + } + #endregion + + /// Put Rot, Call Rot, RR, Strangle and ATM + /// operation go call this + private void _send_curve_operation_request(IEnumerable exp_list, VolCurveMovementOperation curve_operation, + bool is_up, bool cascade_up, bool cascade_down) { + _send_curve_action_request(exp_list.ToDictionary(e => e.ToVSExp(), e => new VolCurveAction(VolSurfaceUtilityFunctions.add_side_to_curve_operation(curve_operation, is_up))), + cascade_up, cascade_down); + } + + private void _send_curve_action_request(IDictionary exp_action_map, + bool cascade_up, bool cascade_down) { + if (_state == DisplayModelState.Idle || _state == DisplayModelState.ResponseReady) { + DisplayModelData curr_data = _get_current_data(); + VolSurfaceCalculationRequest req = new VolSurfaceCalculationRequest(curr_data.vs_output.volsurface_input, _request_version_no++, exp_action_map, + cascade_up, cascade_down); + _change_state(DisplayModelState.WaitingForCalcResponse); + _bus.post(SparkTags.VolSurfaceCalculationRequestTag(_vs_id), req); + } else + _log_bad_transition(_state, "set candidate grid"); + } + + + private void _change_state(DisplayModelState new_state) { + bool dirty_before = _translate_to_dirty(_state), + dirty_after = _translate_to_dirty(new_state); + // mbts.Logger.log(bts.log.Level.Info, bts.log.Subsystem.ui, + // String.Format("State change {0}->{1}", _state.ToString(), new_state.ToString())); + bts.Log.Ui.info(String.Format("State change {0}->{1}", _state.ToString(), new_state.ToString())); + _state = new_state; + if (dirty_before != dirty_after && on_dirty_change != null) { + _bus.post(SparkTags.VolSurfaceDirtyStateTag(_vs_id), dirty_after); + on_dirty_change(); + } + } + + public bool is_dirty { get { return _translate_to_dirty(_state); } } + + private DisplayModelData _get_current_data() { + if (_state == DisplayModelState.Idle) + return _committed_data; + else if (_state == DisplayModelState.ResponseReady) + return _candidate_data; + else + return null; + } + + private void _copy_time_parameters(VolSurfaceInput source, ref VolSurfaceInput target) { + target.surface_parameters = target.surface_parameters ?? new VolSurfaceParameters(); + target.surface_parameters.time_parameters = target.surface_parameters.time_parameters ?? new VolSurfaceTimeParameters() { input_time = DateTime.MinValue, auto_decay_points = new List>() }; + if (source != null && source.surface_parameters != null) { + target.surface_parameters.vol_time = source.surface_parameters.vol_time; + if (source.surface_parameters.time_parameters != null) { + target.surface_parameters.time_parameters.input_time = source.surface_parameters.time_parameters.input_time; + target.surface_parameters.time_parameters.auto_decay_points = source.surface_parameters.time_parameters.auto_decay_points == null ? target.surface_parameters.time_parameters.auto_decay_points : source.surface_parameters.time_parameters.auto_decay_points.ToList(); + } + } + } + + #region Stateless Helpers + private static void _log_graphs(bool is_committed, IDictionary>> graph_map) { + foreach (KeyValuePair>> p in graph_map) { + StringBuilder sb = new StringBuilder(p.Key.ToString()); + sb = sb.AppendLine(is_committed ? "Committed" : "Candidate"); + foreach (Tuple t in p.Value) + sb = sb.AppendLine(String.Format("x:{0} y:{1}", t.Item1, t.Item2)); + //mbts.Logger.log(bts.log.Level.Info, bts.log.Subsystem.gen, sb.ToString()); + bts.Log.Gen.info(String.Format("{0}", sb.ToString())); + } + } + + private static void _log_bad_transition(DisplayModelState state, string action) { + //mbts.Logger.log(bts.log.Level.Error, bts.log.Subsystem.ui, String.Format("{0}:{1}", state, action)); + bts.Log.Ui.error(String.Format("{0}:{1}", state, action)); + } + + private static bool _translate_to_dirty(DisplayModelState state) { + return state == DisplayModelState.WaitingForCalcResponse || state == DisplayModelState.ResponseReady; + } + + #endregion + + + public void Dispose() { + if (_publish_lifetime) + _bus.post(SparkTags.VolSurfaceActiveUITag(_vs_id), true); + Disposable.dispose(ref _subscriptions); + } + } +} \ No newline at end of file diff --git a/src/client/spark/core/Bus/SparkTags.cs b/src/client/spark/core/Bus/SparkTags.cs index 5f49483f5..97683f486 100644 --- a/src/client/spark/core/Bus/SparkTags.cs +++ b/src/client/spark/core/Bus/SparkTags.cs @@ -15,6 +15,7 @@ using System.Threading.Tasks; using bts.api.analytics; using mbts.analytics; using mbts.ui.converters; +using mbts.spark.filters; namespace mbts.spark { @@ -289,6 +290,8 @@ namespace mbts.spark { public static ITag MessageDisplayTag { get; } = new SparkTag("MessageDisplayTag"); + public static ITag VolSurfaceLaunchTheoWindow { get; } = + new SparkTag("VolSurfaceLaunchTheoWindow"); #endregion