169 lines
8.5 KiB
C#
169 lines
8.5 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
using bts.api;
|
|
|
|
using mbts.analytics;
|
|
|
|
namespace mbts.spark {
|
|
// All local changes to the VolSurface that trigger calculations
|
|
// are handled here.
|
|
// Subs :
|
|
// 1. VS Calc Req
|
|
// 2. VS Nonvol Data
|
|
// 3. Dirty
|
|
// Pubs :
|
|
// 1. Calc Resp
|
|
public class SingleVolSurfaceRequestCalculator : IDisposable {
|
|
private readonly int _vs_id;
|
|
private readonly HashSet<string> _symbols;
|
|
private readonly ThreadedBlackboard _bb;
|
|
private readonly ITag<VolSurfaceCalculationRequest> _in_bb_request_tag;
|
|
private readonly ITag<VolSurfaceNonVolData> _in_bb_nonvol_data_tag;
|
|
private readonly ITag<VolSurfaceStandardTime> _in_bb_vs_standard_time_tag;
|
|
private readonly ITag<VolSurfaceEnums.MarketSide> _in_bb_market_impliedvol_side_tag;
|
|
private readonly ITag<bool> _in_bb_dirty_tag;
|
|
private HighPerformanceTimer _timer = new HighPerformanceTimer();
|
|
/// data
|
|
private VolSurfaceOutput _last_output;
|
|
|
|
public SingleVolSurfaceRequestCalculator(int vs_id, IEnumerable<string> symbols,
|
|
ThreadedBlackboard threaded_bb) {
|
|
bts.Log.Gen.info($"SingleVolSurfaceRequestCalculator cons vs_id:{vs_id}");
|
|
_vs_id = vs_id;
|
|
_symbols = new HashSet<string>(symbols);
|
|
_bb = threaded_bb;
|
|
_in_bb_request_tag = SparkTags.VolSurfaceCalculationRequestTag(vs_id);
|
|
_in_bb_nonvol_data_tag = SparkTags.VolSurfaceNonVolDataTag(vs_id);
|
|
_in_bb_vs_standard_time_tag = SparkTags.VolSurfaceStandardTimeTag(vs_id);
|
|
_in_bb_market_impliedvol_side_tag = SparkTags.VolSurfaceMarketImpliedVolSide(vs_id);
|
|
_in_bb_dirty_tag = SparkTags.VolSurfaceDirtyStateTag(vs_id);
|
|
_bb.subscribe(_in_bb_request_tag);
|
|
_bb.subscribe(_in_bb_nonvol_data_tag);
|
|
_bb.subscribe(_in_bb_vs_standard_time_tag);
|
|
_bb.subscribe(_in_bb_vs_standard_time_tag);
|
|
_bb.subscribe(_in_bb_dirty_tag);
|
|
_bb.data_callback += _on_bb_data;
|
|
_recompute_and_publish(true);
|
|
}
|
|
|
|
private void _on_bb_data(object tag, object data) {
|
|
if (_in_bb_request_tag.Equals(tag) || _in_bb_dirty_tag.Equals(tag))
|
|
_recompute_and_publish(true);
|
|
else if (_in_bb_nonvol_data_tag.Equals(tag) || _in_bb_vs_standard_time_tag.Equals(tag))
|
|
_recompute_and_publish(false);
|
|
|
|
}
|
|
|
|
private void _recompute_and_publish(bool is_new_request) {
|
|
object is_dirty_obj = _bb.sec_thread_retrieve_from_cache(_in_bb_dirty_tag);
|
|
bool is_dirty = is_dirty_obj is bool && (bool)is_dirty_obj;
|
|
VolSurfaceNonVolData nonvol_data = _bb.read_state(_in_bb_nonvol_data_tag);
|
|
VolSurfaceStandardTime vs_standard_time = _bb.read_state(_in_bb_vs_standard_time_tag);
|
|
if (is_dirty && nonvol_data != null) {
|
|
_timer.start();
|
|
VolSurfaceCalculationRequest curr_req = _bb.read_state(_in_bb_request_tag),
|
|
effective_req = null;
|
|
if (is_new_request)
|
|
effective_req = curr_req;
|
|
else {
|
|
if (_last_output != null)
|
|
effective_req =
|
|
new VolSurfaceCalculationRequest(_last_output.volsurface_input, curr_req.request_id);
|
|
}
|
|
if (effective_req != null) {
|
|
IDictionary<VolSurfaceExpiration, VolSurfaceExpirationAuxiliaryData> aux_data_map =
|
|
VolSurfaceUtilityFunctions.compute_aux_data(effective_req.volsurface_input,
|
|
nonvol_data.input,
|
|
nonvol_data.driver_price_map,
|
|
vs_standard_time, true);
|
|
IDictionary<VolSurfaceExpiration, VolCurveAction> action_map =
|
|
_post_process_action(effective_req, aux_data_map);
|
|
_last_output = GeneralVolSurfaceCalculator.compute(effective_req.volsurface_input,
|
|
nonvol_data.contracts,
|
|
aux_data_map,
|
|
action_map,
|
|
null,
|
|
effective_req.cascade_up,
|
|
effective_req.cascade_down);
|
|
_timer.stop();
|
|
bts.Log.Gen.info($"SingleVolSurfaceRequestCalculator._recompute_and_publish time:" +
|
|
$"{_timer.lastIntervalTime} vs_output:{_last_output.log_string()}");
|
|
_bb.post(SparkTags.VolSurfaceCalculationResponseTag(_vs_id),
|
|
new VolSurfaceCalculationResponse(_last_output, effective_req.request_id));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Computes the impl vol if the action is fit to market
|
|
private IDictionary<VolSurfaceExpiration, VolCurveAction> _post_process_action(
|
|
VolSurfaceCalculationRequest req,
|
|
IDictionary<VolSurfaceExpiration, VolSurfaceExpirationAuxiliaryData> aux_data_map) {
|
|
IDictionary<VolSurfaceExpiration, VolCurveAction> rv = req.action_map;
|
|
/// TODO : VolCurveAction needs to be structured better. The UI enforces that
|
|
/// all exps have the same action, but the structure doesnt. So here the UI
|
|
/// constraint is flowing in
|
|
if (rv != null && rv.Count > 0) {
|
|
VolCurveAction rep_action = rv.ElementAt(0).Value;
|
|
if (rep_action.action_type == VolCurveAction.ActionType.FitToMarket) {
|
|
IDictionary<VolSurfaceExpiration, VolCurveMarketImpliedVolData> impl_vol_map =
|
|
_fill_in_implied_vols(req.volsurface_input, req.action_map, aux_data_map,
|
|
req.cascade_up, req.cascade_down);
|
|
rv = impl_vol_map.ToDictionary(kv => kv.Key, kv => new VolCurveAction(
|
|
new VolCurveMarketFitAction(rep_action.market_fit_action.fit_action, kv.Value,
|
|
rep_action.market_fit_action.use_weighted_regression)));
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
private IDictionary<VolSurfaceExpiration, VolCurveMarketImpliedVolData> _fill_in_implied_vols(
|
|
VolSurfaceInput vs_inp,
|
|
IDictionary<VolSurfaceExpiration, VolCurveAction> action_map,
|
|
IDictionary<VolSurfaceExpiration, VolSurfaceExpirationAuxiliaryData> aux_data_map,
|
|
bool cascade_up, bool cascade_down) {
|
|
IDictionary<VolSurfaceExpiration, VolCurveMarketImpliedVolData> rv =
|
|
new Dictionary<VolSurfaceExpiration, VolCurveMarketImpliedVolData>();
|
|
VolCurveAction rep_action = action_map.ElementAt(0).Value;
|
|
HashSet<VolSurfaceExpiration> master_exps =
|
|
VolSurfaceUtilityFunctions.get_master_expirations(vs_inp, true);
|
|
IEnumerable<VolSurfaceExpiration> applicable_exps;
|
|
if (cascade_up || cascade_down)
|
|
applicable_exps =
|
|
VolSurfaceUtilityFunctions.get_exp_list_from_cascade(
|
|
vs_inp.surface_parameters.curve_parameters_map.Select(t => t.Item1),
|
|
action_map.Keys, cascade_up, cascade_down);
|
|
else
|
|
applicable_exps = action_map.Keys;
|
|
applicable_exps = applicable_exps.Where(vs_exp => master_exps.Contains(vs_exp));
|
|
|
|
VolSurfaceEnums.MarketSide impliedvol_side =
|
|
SingleVolSurfaceMarketImpliedVolSource._get_market_impliedvol_side(_bb, _vs_id);
|
|
foreach (VolSurfaceExpiration vs_exp in applicable_exps) {
|
|
VolSurfaceExpiration md_exp;
|
|
VolCurveMarketImpliedVolData exp_impl_data =
|
|
VolSurfaceCoreFunctions.compute_implied_vols(vs_inp, vs_exp, aux_data_map,
|
|
arg_vs_exp => SingleVolSurfaceMarketImpliedVolSource.get_option_bbo(_bb, arg_vs_exp),
|
|
impliedvol_side,
|
|
SingleVolSurfaceMarketImpliedVolSource._ignore_market_implied_vol_source_settings(
|
|
_bb, _vs_id),
|
|
out md_exp);
|
|
rv[vs_exp] = exp_impl_data;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
#region IDisposable
|
|
private bool _disposed = false;
|
|
public void Dispose() {
|
|
if (!_disposed) {
|
|
_disposed = true;
|
|
_bb.data_callback -= _on_bb_data;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
} |