From 4dbafcab916ccd4c5b244b39f2eee00a84836965 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 18 Aug 2023 05:44:12 +0000 Subject: [PATCH] TaskingEye can shoot deep in the book as well --- .../algo/algo_orders/RegisterDorman.cpp | 3 + .../algo/algo_orders/TaskingEyeAlgo.cpp | 135 +++++++++++++----- 2 files changed, 105 insertions(+), 33 deletions(-) diff --git a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp index 0bc2d0e0c..10e5c6127 100644 --- a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp @@ -300,6 +300,9 @@ extern "C" void init_execution_tester_plugin(bts::SparkServices &srv) { extern "C" void init_task_eye_plugin(bts::SparkServices &srv) { DynamicOrderDescriptor tasking_eye_algo; tasking_eye_algo.set_dynamic_order_type("Tasking Eye"); + // if this is set to true, it waits for the existance of Signal File + *tasking_eye_algo.add_param_desc() = param_bool("Wait For Signal"); + *tasking_eye_algo.add_param_desc() = param_string("Signal File"); *tasking_eye_algo.add_param_desc() = param_string("Account"); *tasking_eye_algo.add_param_desc() = param_double("Edge"); *tasking_eye_algo.add_param_desc() = param_double("Shot Size"); diff --git a/src/lib/orderman/orders/algo/algo_orders/TaskingEyeAlgo.cpp b/src/lib/orderman/orders/algo/algo_orders/TaskingEyeAlgo.cpp index cf21cc2d3..f40050113 100644 --- a/src/lib/orderman/orders/algo/algo_orders/TaskingEyeAlgo.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/TaskingEyeAlgo.cpp @@ -25,8 +25,10 @@ #include #include #include +#include #include #include +#include #include #include #include @@ -233,6 +235,8 @@ struct TaskingEyeAlgo ::PImpl { IAlgoServices *service_ptr = nullptr; analytics::ITheoCalculator const *theo_calc = nullptr; TEAState state = TEAState::ACTIVE; + bool wait_for_signal = false; + std::string signal_file = ""; double edge = 100000; double shot_size = 0; double target_qty = 0; @@ -266,22 +270,29 @@ TaskingEyeAlgo::~TaskingEyeAlgo() {} OrderOpResult TaskingEyeAlgo::do_before_launch( IBeforeLaunchAlgoServices &serv) { auto is_data_valid = [&]() { - return greater_then_eq(0.1, me->shot_size) && - greater_then_eq(1, me->target_qty) && - greater_then_eq(1, me->max_shots_per_window) && - greater_then_eq(1000000000, me->window_size_nanos) && - me->side != api::SIDE_UNDEFINED; + bool rv = greater_then_eq(0.1, me->shot_size) && + greater_then_eq(1, me->target_qty) && + greater_then_eq(1, me->max_shots_per_window) && + greater_then_eq(1000000000, me->window_size_nanos) && + me->side != api::SIDE_UNDEFINED; + bool signal_correct = !me->wait_for_signal || !me->signal_file.empty(); + rv = rv && signal_correct; + return rv; }; LOG(OrderMan, Info, "TaskingEyeAlgo::do_before_launch order_key: {} security: {} " "definition: {}", serv.order_key().value(), utils::pb::to_string(serv.security()), utils::pb::to_string(serv.definition())); - // TODO, remove this sleep_log(); auto &def = serv.definition(); if (def.has_custom_def() && def.custom_def().has_dynamic()) { const auto &d_params = def.custom_def().dynamic().order_params(); + auto wait_for_signal = get_if(d_params, "Wait For Signal"); + me->wait_for_signal = + wait_for_signal.has_value() ? wait_for_signal.value() : false; + auto signal_file = get_if(d_params, "Signal File"); + me->signal_file = signal_file.has_value() ? signal_file.value() : ""; me->edge = get_if(d_params, "Edge").value(); LOG(OrderMan, Info, "TaskingEyeAlgo::do_before_launch edge: {}", me->edge); @@ -335,11 +346,12 @@ OrderOpResult TaskingEyeAlgo::do_before_launch( "TaskingEyeAlgo::do_before_launch algo constructed order_key: " "{} " "edge: {} shot_size: {} side: {} target_qty: {} " - "max_shots_per_window: {} window_size_nanos: {} n_secs: {}", + "max_shots_per_window: {} window_size_nanos: {} n_secs: {} " + "wait_for_signal: {} signal_file: {}", serv.order_key(), me->edge, me->shot_size, bts::api::Side_Name(me->side), me->target_qty, me->max_shots_per_window, me->window_size_nanos, - me->sec_map.size()); + me->sec_map.size(), me->wait_for_signal, me->signal_file); return {}; } } @@ -458,9 +470,9 @@ void TaskingEyeAlgo::on_theos( if (!sec_data.driver_sec_key.has_value() || sec_data.driver_sec_key->value() != driver.value()) { LOG(OrderMan, Info, - "TaskingEyeAlgo::on_theos order_key: {} subscribing to driver " - "sec_key: {}", - me->service_ptr->order_key(), driver.value()); + "TaskingEyeAlgo::on_theos order_key: {} subscribing to driver for " + "sec_key: {} driver_key: {}", + me->service_ptr->order_key(), sec_key, driver.value()); sec_data.driver_sec_key = SecurityKey(driver.value()); sub_to_driver(SecurityKey(driver.value())); } @@ -474,8 +486,14 @@ void TaskingEyeAlgo::on_position(PositionUpdate const &pu) { } void TaskingEyeAlgo::_evaluate_and_shoot() { - if (me->state != TEAState::ACTIVE) + if (me->state != TEAState::ACTIVE) { + LOG(OrderMan, Warn, + "TaskingEyeAlgo::_evaluate_and_shoot order_key: {} state is not " + "active state: {} ", + me->service_ptr->order_key(), me->state); return; + } + auto max_shots_per_win_reached = [&]() { return n_recent_shots(me->shots, me->window_size_nanos) >= me->max_shots_per_window; @@ -486,12 +504,36 @@ void TaskingEyeAlgo::_evaluate_and_shoot() { return true; return false; }; + auto signal_condition_met = [&]() { + if (me->wait_for_signal) { + return std::filesystem::exists(me->signal_file); + } else + return true; + }; + if (!signal_condition_met()) { + // Log ? + LOG(OrderMan, Warn, + "TaskingEyeAlgo::_evaluate_and_shoot order_key: {} Waiting for " + "Signal", + me->service_ptr->order_key()); + return; + } for (auto &kv : me->sec_map) { auto sec_key = kv.first; - if (max_shots_per_win_reached()) + if (max_shots_per_win_reached()) { + LOG(OrderMan, Warn, + "TaskingEyeAlgo::_evaluate_and_shoot order_key: {} " + "max_shots_per_win_reached", + me->service_ptr->order_key()); return; - if (sec_has_active_order(sec_key)) + } + if (sec_has_active_order(sec_key)) { + LOG(OrderMan, Warn, + "TaskingEyeAlgo::_evaluate_and_shoot sec_key: {} has working " + "order, skipping", + sec_key.value()); continue; + } Price price; Quantity qty; if (_in_shooting_zone(sec_key, price, qty)) { @@ -519,8 +561,13 @@ bool TaskingEyeAlgo::_in_shooting_zone( TEASecData const &sec_data = it->second; const md::PriceSize &driver_bid = sec_data.driver_book.bid().at(0); const md::PriceSize &driver_ask = sec_data.driver_book.ask().at(0); - if (eq(driver_bid.size(), 0) || eq(driver_ask.size(), 0)) + if (eq(driver_bid.size(), 0) || eq(driver_ask.size(), 0)) { + LOG(OrderMan, Warn, + "TaskingEyeAlgo::_in_shooting_zone no driver for sec_key: {} " + "driver_bid_qty: {} driver_ask_qty: {}", + sec_key, driver_bid.size(), driver_ask.size()); return false; + } // finding weighted mean (TODO change it to mark price later) double driver = (driver_bid.price() * driver_bid.size() + driver_ask.price() * driver_ask.size()) / @@ -530,33 +577,55 @@ bool TaskingEyeAlgo::_in_shooting_zone( // TODO normalize theo double theo = ptp.theo(); theo = theo / driver; - if (me->side == api::SIDE_BUY) { + // auto analyze_buy = + auto analyze_buy = [&](const md::PriceSize &md_ask, double theo, + size_t level, Price &price, Quantity &qty) -> bool { double ee_buy_pr = theo - me->edge; - const md::PriceSize &md_ask = sec_data.sec_book.ask().at(0); - LOG(OrderMan, Diag, - "TaskingEyeAlgo::_in_shooting_zone sec_key: {} driver: {} theo: " - "{} " - "ee_price: {} md: {}/{}", - sec_key, driver, theo, ee_buy_pr, md_ask.price(), md_ask.size()); + bool rv = false; if (greater_then_eq(1, md_ask.size()) && greater_then_eq(md_ask.price(), ee_buy_pr)) { price = Price(md_ask.price()); - qty = std::min(static_cast(md_ask.size()), me->shot_size); - return true; + qty = me->shot_size; + rv = true; } - } else { - double ee_sell_pr = theo + me->edge; - const md::PriceSize &md_bid = sec_data.sec_book.bid().at(0); LOG(OrderMan, Diag, - "TaskingEyeAlgo::_in_shooting_zone sec_key: {} driver: {} theo: " - "{} " - "ee_price: {} md: {}/{}", - sec_key, driver, theo, ee_sell_pr, md_bid.price(), md_bid.size()); + "TaskingEyeAlgo::_in_shooting_zone::analyze_buy sec_key: {} " + "theo: {} level: {}" + "ee_buy_pr: {} rv: {}", + sec_key, level, theo, ee_buy_pr, rv); + return rv; + }; + auto analyze_sell = [&](const md::PriceSize &md_bid, double theo, + size_t level, Price &price, Quantity &qty) -> bool { + double ee_sell_pr = theo + me->edge; + bool rv = false; if (greater_then_eq(1, md_bid.size()) && greater_then_eq(ee_sell_pr, md_bid.price())) { price = Price(md_bid.price()); - qty = std::min(static_cast(md_bid.size()), me->shot_size); - return true; + qty = me->shot_size; + rv = true; + } + LOG(OrderMan, Diag, + "TaskingEyeAlgo::_in_shooting_zone::analyze_sell sec_key: {} theo:" + "{} level: {} ee_sell_pr: {} rv: {}", + sec_key, theo, level, ee_sell_pr, rv); + return rv; + }; + if (me->side == api::SIDE_BUY) { + const auto &ask_book = sec_data.sec_book.ask(); + for (int i = ask_book.size() - 1; i >= 0; i--) { + const auto &md_ask = ask_book.at(i); + if (analyze_buy(md_ask, theo, i, price, qty)) { + return true; + } + } + } else { + const auto &bid_book = sec_data.sec_book.bid(); + for (int i = bid_book.size() - 1; i >= 0; i--) { + const md::PriceSize &md_bid = bid_book.at(i); + if (analyze_sell(md_bid, theo, i, price, qty)) { + return true; + } } } return false;