//
// *****************************************
// **** Setup Begin() ****
// *****************************************
/// <summary>
/// This is called after all Engines have been created, and added to the master
/// list inside the Strategy (IEngineContainer).
/// As a convenience, the PricingEngine class locates useful Engines and keeps
/// pointers to them.
/// </summary>
/// <param name="myEngineHub"></param>
/// <param name="engineContainer"></param>
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
// Locate engines we need.
m_MarketSubscribers = new List <IMarketSubscriber>();
foreach (IEngine iEngine in engineContainer.GetEngines())
{
if (iEngine is ZGraphEngine)
{
m_GraphEngine = (ZGraphEngine)iEngine; // PricingEngines also plot a lot.
}
else if (iEngine is IMarketSubscriber)
{
m_MarketSubscribers.Add((IMarketSubscriber)iEngine);
}
}
//
// Subscribe to Pricing instruments.
//
List <InstrumentName> instruments = new List <InstrumentName>();
foreach (PriceLeg leg in m_Legs) // Subscribe to each "PricingLeg" object.
{
instruments.Add(leg.InstrumentName);
}
this.ParentStrategy.StrategyHub.SubscribeToMarketInstruments(instruments, this.ParentStrategy);
}//SetupBegin()
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine ieng in engineContainer.GetEngines())
{ // Find order Engine
if (ieng is IOrderEngine)
{
this.m_IOrderEngine = (IOrderEngine)ieng; // find our order engine
}
}
if (m_IOrderEngine is SingleLegExecutor)
{ // if this is a single leg order engine
m_SingleLegExecutor = (SingleLegExecutor)m_IOrderEngine;
this.m_Leg = m_SingleLegExecutor.m_PriceLeg;
m_MaxPossibleWorkingQuoteQtyPerLot += (int)(Math.Abs(m_Leg.Weight) * 2); // leg ratios * 2 (each side)
}
// If we subscribe to order book creation, we can be sure to get all the info for all fills and submissions
// this only works if create order books after setup beging.
m_IOrderEngine.GetExecutionListener().OrderBookCreated += new EventHandler(ExecutionListener_OrderBookCreated);
if (m_Hub is ExecutionHub)
{ // set up ITimer to work
((ExecutionHub)m_Hub).SubscribeToTimer((ITimerSubscriber)m_ExecutionContainer.m_ExecutionListener);
m_ExecutionContainer.m_ExecutionListener.SubscribeToTimer(this); // subscrie to updates
}
}
/// <summary>
/// This is a convenient overload for the Guis. They will have a container that
/// is one-to-one with the engines they are interested in getting parameters for.
/// </summary>
/// <param name="engineHubName">StrategyHub of engines with desired parameters</param>
/// <param name="container">a container that has engineId's that match those you are interested in.</param>
/// <returns></returns>
public static List <EngineEventArgs> RequestAllParameters(string engineHubName, IEngineContainer container)
{
List <EngineEventArgs> requestList = new List <EngineEventArgs>();
List <IEngine> engines = container.GetEngines();
foreach (IEngine engine in engines)
{
requestList.Add(RequestAllParameters(engineHubName, container.EngineContainerID, engine.EngineID));
}
return(requestList);
}
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
m_Log = ((ExecutionHub)myEngineHub).Log;
foreach (IEngine iEng in engineContainer.GetEngines())
{// find our needed engine pointers
if (iEng is ExecutionEngines.OrderEngines.Spreader)
{
m_Quoter = (ExecutionEngines.OrderEngines.Spreader)iEng;
}
}
}
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine eng in engineContainer.GetEngines())
{
if (eng is IOrderEngine)
{ // find our orer engine and our execution listner
m_ExecutionListener = ((IOrderEngine)eng).GetExecutionListener();
continue;
}
}
}
}//SetupInitialize()
//
//
//
//
// ************************************************
// **** SetupBegin() ****
// ************************************************
/// <summary>
/// </summary>
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
//
// Master Remote-Engines must send requests to ExecutionHub now.
//
if (m_IsSubEngine == false)
{
// Count number of (master) remote engines found in this strategy.
// Master remote engines are those connected directly to the Strategy,
// without being held by another engine.
// Only masters broadcast their xml to the ExecutionHub, and other sub-engine
// engines are included as subelements of their master's broadcast.
// (If each remote engine broadcasted separately, the ExecHub would have to know how
// to put them all back together again... that is, who owned whom.)
int remoteMasterEngineCount = 0;
foreach (IEngine iEng in engineContainer.GetEngines())
{
if (iEng is ExecutionController && ((ExecutionController)iEng).m_IsSubEngine == false)
{
remoteMasterEngineCount++;
}
//if (iEng is RemoteEngine) // now count all remote engines
// remoteMasterEngineCount++;
}
//
// Create my engine creation request
//
Dictionary <Type, string[]> rules = new Dictionary <Type, string[]>();
rules.Add(this.GetType(), new string[] { "GetClassName", string.Empty, string.Empty });
string xmlString = Stringifiable.Stringify(this, rules);
EngineEventArgs e = new EngineEventArgs();
e.MsgType = EngineEventArgs.EventType.NewEngine;
e.Status = EngineEventArgs.EventStatus.Request;
e.EngineID = m_EngineID;
e.EngineContainerID = m_EngineContainerId;
e.DataObjectList = new List <object>();
e.DataObjectList.Add(xmlString); // 0 - engine specs
e.DataObjectList.Add(m_LocalEngineHubName); // 1 - engine hub name
e.DataObjectList.Add(remoteMasterEngineCount.ToString()); // 2 - number of engines remote hub should expect from this EngineContainer
// Send request to remote.
if (m_RemoteEngineHub != null && m_RemoteEngineHub.HubEventEnqueue(e))
{
Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} sent creation request to remote.", m_RemoteEngineClassName);
}
else
{
Log.NewEntry(LogLevel.Minor, "SetupBegin: Remote-{0} failed to send creation request to remote.", m_RemoteEngineClassName);
}
} // master remote-engine sends request.
} //SetupBegin()
}// SetupInitialize()
//
// *************************************************************
// **** Setup Begin() ****
// *************************************************************
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine iEng in engineContainer.GetEngines())
{
if (iEng is Risk.RiskManager)
{
m_RiskManager = (Risk.RiskManager)iEng;
}
}
if (m_RiskManager == null)
{
throw new NotImplementedException("All Strategies Must Have a Risk Manager, Please Add One To Your User Config");
}
}//SetupBegin().
//
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
foreach (IEngine ieng in engineContainer.GetEngines())
{ // Find Pricing Engine
if (ieng is PricingEngine)
{
PricingEngine priceEngine = (PricingEngine)ieng;
this.m_Leg = priceEngine.m_Legs[0]; // keep pointer to legs.
m_MaxPossibleWorkingQuoteQtyPerLot += (int)(Math.Abs(m_Leg.Weight) * 2); // leg ratios * 2 (each side)
}
else if (ieng is OrderEngine)
{
this.m_OrderEngine = (OrderEngine)ieng; // find our order engine
}
}
((StrategyHub)myEngineHub).SubscribeToTimer((Strategy)engineContainer, this); // get periodic updates from ITimer.
}
}// SetupInitialize()
//
// *************************************************************
// **** Setup Begin() ****
// *************************************************************
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
//
// Subscribe to events
//
m_ExecutionListener.InstrumentFound += new EventHandler(ExecutionListener_InstrumentsFound);
foreach (IEngine iEng in engineContainer.GetEngines())
{
if (iEng is ExecutionEngines.Risk.RiskManager)
{
m_RiskManager = (ExecutionEngines.Risk.RiskManager)iEng;
}
}
if (m_RiskManager == null)
{
throw new NotImplementedException("All Strategies Must Have a Risk Manager, Please Add One To Your User Config - Must be UV.Execution.Risk.RiskManager type");
}
}//SetupBegin().
//
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
m_Log = ((ExecutionHub)myEngineHub).Log;
foreach (IEngine iEng in engineContainer.GetEngines())
{// find our needed engine pointers
if (iEng is ExecutionEngines.OrderEngines.Spreader)
{
m_Spreader = (ExecutionEngines.OrderEngines.Spreader)iEng;
}
}
if (m_Spreader == null)
{
throw new Exception("Hedger Couldn't Find Quoter");
}
m_OrderBook = m_Spreader.m_ExecutionListener.CreateOrderBook(m_SpreaderLeg.m_PriceLeg.InstrumentName, m_SpreaderLeg.DefaultAccount); // create new order book for this leg's hedge fulls
m_InternalLegId = m_Spreader.m_SpreaderLegs.IndexOf(m_SpreaderLeg); // set our internal id.
m_Spreader.MarketsReadied += new EventHandler(Quoter_MarketsReadied); // we will Finish our set up once we get this call.
m_HedgeRuleManager = m_SpreaderLeg.m_HedgeRuleManager;
}
//
// *****************************************
// **** Setup Begin() ****
// *****************************************
/// <summary>
/// This is called after all Engines have been created, and added to the master
/// list inside the Strategy (IEngineContainer).
/// As a convenience, the PricingEngine class locates useful Engines and keeps
/// pointers to them.
/// </summary>
/// <param name="myEngineHub"></param>
/// <param name="engineContainer"></param>
public override void SetupBegin(IEngineHub myEngineHub, IEngineContainer engineContainer)
{
base.SetupBegin(myEngineHub, engineContainer);
//
// Subscribe to economic numbers of legs.
//
List <InstrumentName> instruments = new List <InstrumentName>();
foreach (IEngine iEngine in engineContainer.GetEngines())
{
if (iEngine is PricingEngine)
{
PricingEngine pricingEngine = (PricingEngine)iEngine;
foreach (Lib.MarketHubs.PriceLeg leg in pricingEngine.m_Legs)
{
if (!instruments.Contains(leg.InstrumentName))
{
instruments.Add(leg.InstrumentName);
}
}
}
}
//QueryBase query = null;
//this.ParentStrategy.StrategyHub.RequestQuery(query, this.QueryResponseHandler, this.ParentStrategy);
//
// Subscribe to start/end trading times
//
// If StartTime=EndTime => strategy never shuts off.
if (ParentStrategy.QueryItem != null && ParentStrategy.StrategyHub.m_Alarm != null &&
ParentStrategy.QueryItem.StartTime.CompareTo(ParentStrategy.QueryItem.EndTime) != 0)
{
Random random = new Random();
StrategyQueryItem strategyItem = ParentStrategy.QueryItem;
Alarm alarm = ParentStrategy.StrategyHub.m_Alarm;
// Collect today's time/date
DateTime today = ParentStrategy.StrategyHub.GetLocalTime().Date; // collect nearest day
DateTime day = today;
if (day.CompareTo(strategyItem.StartDate) < 0)
{
day = strategyItem.StartDate;
}
AlarmEventArg eventArg; // my callback event arg.
while (day.CompareTo(strategyItem.EndDate) <= 0) // Loop thru each day and set start/end alarms.
{
// Create start event.
DateTime dt = day.Add(strategyItem.StartTime);
eventArg = new AlarmEventArg();
eventArg.State = StrategyState.Normal;
double secs = m_StartTimeSeconds + m_StartTimeSeconds * (0.01 * random.Next(0, m_RandomSlopPercent[0]));
eventArg.TimeStemp = dt.AddSeconds(secs); // start at start time or after.
alarm.Set(dt, this.AlarmEventHandler, eventArg);
// Create stop event.
dt = day.Add(strategyItem.EndTime); // exit time (or earlier)
double lastSecs = double.MaxValue;
for (int i = 0; i < m_ExitTimeSeconds.Length; ++i)
{
if (m_ExitTimeSeconds[i] != double.NaN)
{
StrategyState state = (StrategyState)(i + (int)StrategyState.ExitOnly);
eventArg = new AlarmEventArg();
eventArg.State = state;
secs = m_ExitTimeSeconds[i] + m_ExitTimeSeconds[i] * (0.01 * random.Next(0, m_RandomSlopPercent[i]));
secs = Math.Max(0, Math.Min(secs, lastSecs)); // don't allow this exit level to be earlier than previous one.
lastSecs = secs - 1.0; // therefore, states padding is strictly decreasing in seconds!
DateTime dt2 = dt.AddSeconds(-secs);
alarm.Set(dt, this.AlarmEventHandler, eventArg);
}
}
// Increment day
day = day.AddDays(1.0).Date; // increment until past endDate or ...
if (day.DayOfWeek == DayOfWeek.Saturday && day != today) // ... its Saturday (but continue if today is Sat.).
{
break;
}
} //wend day
}
} //SetupBegin()