OpenQuant 2014 FAQ

Frequently Asked Questions

03.11.2015
SmartQuant Ltd
Dr. Anton Fokin
How to build bars from bids, asks or middle prices .................................................................................. 3
How to download historical data in scenario............................................................................................ 3
How to save downloaded historical data to OpenQuant database .......................................................... 3
How to backtest a strategy with downloaded historical data .................................................................. 4
How to access data series in OpenQuant database .................................................................................. 5
How to pass additional parameters to instruments ................................................................................. 6
How to define a number of digits displayed in instrument prices ............................................................ 6
How to develop and register a custom object streamer .......................................................................... 7
How to access n-bars ago bar in a bar series ............................................................................................ 9
How to work with multiple time frames ................................................................................................... 9
How to filter market data and other events ...........................................................................................11
How to develop complex custom indicators ...........................................................................................12
How to set parameters for a particular instance of Instrument Strategy...............................................14
How to change the FileServer port .........................................................................................................15
How to control event bus latency in the real time mode .......................................................................16
How to change path to local data files (instrument and market database) ...........................................16
How to do things periodically (on every session open, close and so on) ...............................................17
How to change chart attributes ..............................................................................................................18
How to plot bids, asks, trades and bars on the same plot ......................................................................20
How to control reminder event order ....................................................................................................22
How to use ExecutionSimulator.Queued property .................................................................................22
How to build bars from bids, asks or middle prices

There are certain cases where you have to build bars on the fly using bids and asks or their combination.
Particularly, FX brokers such as IB don’t provide trade information in their price feed.

You can use BarInput parameter of the BarFactory.Add() method to indicate what data type should be
used for bar construction for this particular BarFactoryItem (or Instrument).

The following code line tells to the BarFactory to build one minute bars for MSFT instrument from
bid/ask middle prices

BarFactory.Add("MSFT", BarType.Time, 60, BarInput.Middle);

How to download historical data in scenario

Use DataManager.GetHIstoricalData .

The Scenario class (as well as the Strategy) class references all managers of the framework
(InstrumentManager, DataManager, etc.) for your convenience, so that you can use them directly to
simplify your code.

The following code snippet downloads historical one minute (60 second) bars from Interactive Brokers
(IB) for Microsoft (MSFT) instrument for last seven days. Indeed you should have MSFT instrument
properties properly set to work with IB (instrument exchange should be set to SMART or other valid IB
exchange, currency to USD and so on).

BarSeries series = DataManager.GetHistoricalBars("IB", "MSFT",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

How to save downloaded historical data to OpenQuant database

Use DataManager.Save(IDataSeries) method to save a series of data objects into OpenQuant database.
Since TickSeries and BarSeries (as well as many other data series classes in SmartQuant framework)
inherit IDataSeries interface, you can call this method to save series of ticks and bars downloaded in the
previous FAQ.

The following code snippet downloads a bar series of historical one minute bars from IB and stores them
in the local OpenQuant database.

BarSeries series = DataManager.GetHistoricalBars("IB", "MSFT",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

DataManager.Save(series);

The DataManager.Save(IDataSeries, SaveMode) method has an option to either add all data from
IDataSeries (SaveMode.Add) or append data (SaveMode.Append). If you select SaveMode.Append
option, only objects with datetime greater than datetime of the last object in the OpenQuant database
will be added to the database.

BarSeries series = DataManager.GetHistoricalBars("IB", "MSFT",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

DataManager.Save(series, SaveMode.Append);

The default value of this option is SaveOption.Add.

If you don’t want to add all objects from the data series, you can add objects one by one using
DataManager.Save(IDataObject, SaveOption) method

BarSeries series = DataManager.GetHistoricalBars("IB", "MSFT",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

for (int i = 0; i < series.Count; i++)

DataManager.Save(series[i]);

How to backtest a strategy with downloaded historical data

You don’t necessarily need to save downloaded historical data to OpenQuant database to backtest a
strategy with this data. You can simply add downloaded series of historical bars or trades to the list of
external data series of the data simulator and run a backtest.

public override void Run()

{
strategy = new MyStrategy(framework, "SMACrossover");

strategy.AddInstrument("AAPL");

BarSeries series = DataManager.GetHistoricalBars("IB", "AAPL",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

DataSimulator.Series.Add(series);

DataSimulator.SubscribeAll = false;

ExecutionSimulator.FillOnBar = true;

StartStrategy();
}

Perhaps if you run the code above, you will see a mixture of data stored in OpenQuant database and
data from downloaded series. In order to avoid this, you can disable subscriptions to data series stored
in OpenQuant database changing DataSimulator.SubscribeTrades, DataSimulator.SubscribeQuotes, etc.
or DataSimulator.SubscribeAll properties

public override void Run()

{
strategy = new MyStrategy(framework, "SMACrossover");

strategy.AddInstrument("AAPL");
 BarSeries series = DataManager.GetHistoricalBars("IB", "AAPL",
DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

DataSimulator.Series.Add(series);

DataSimulator.SubscribeAll = false;

StartStrategy();
}

Finally it’s a good idea to check that you have FillOnBar enabled in the execution simulator, since now
you don’t have any other data than one minute bars in your simulation. Otherwise there will be no
order fills in your strategy.

public override void Run()

{
strategy = new MyStrategy(framework, "SMACrossover");

strategy.AddInstrument("AAPL");

BarSeries series = DataManager.GetHistoricalBars("IB", "AAPL",

DateTime.Now.Date.AddDays(-7), DateTime.Now.Date, BarType.Time, 60);

DataSimulator.Series.Add(series);

DataSimulator.SubscribeAll = false;

ExecutionSimulator.FillOnBar = true;

StartStrategy();
}

How to access data series in OpenQuant database

Use DataManager.GetDataSeries(name). The following code snippet returns a reference to series of one
minute bars of AAPL instrument.

DataSeries series = DataManager.GetDataSeries("AAPL.0.Time.60.Bar");

Data series name can be constructed for bar series using the following rule

instrumentSymbol +’.’ + instrumentId + ‘.’ + barType + ‘.’ + barSize + ‘.Bar’

or

instrumentSymbol + ‘.’ + instrumentId + ‘.’ + Bid

instrumentSymbol + ‘.’ + instrumentId + ‘.’ + Ask

instrumentSymbol + ‘.’ + instrumentId + ‘.’ + Trade

for bid, ask or trade series.

You can also use DataManager.GetDataSeries(Instrument, dataType, barType, barSize) method. The
following code returns the same one minute bar series as the code above.
 DataSeries series = DataManager.GetDataSeries("AAPL", DataObjectType.Bar,
BarType.Time, 60);

How to pass additional parameters to instruments

Use Instrument.Fields property. Instrument.Fields is an ObjectTable, which provides a smart and

resizable array of objects accompanied by helper methods converting objects into commonly used types
like double, integer, string.

Instrument.Fields property is persistent. Objects added by users to the object table are stored in the
instrument data base when InstrumentManager.Save(Instrument) method is called. Note that objects of
user defined classes should have corresponding streamers and such streamers should be registered in
the StreamerManager of SmartQuant Framework. Standard classes, such as double, int, boolean and
string already have registered streamers.

You can learn how to develop custom object streamers in the corresponding FAQ in this document.

Set parameters

Instrument instrument = InstrumentManager.Instruments["MSFT"];

instrument.Fields[0] = 10.25;
instrument.Fields[1] = 5;
instrument.Fields[2] = "Shortable";

InstrumentManager.Save(instrument);

Get parameters

double price = (Double)instrument.Fields[0];

int size = (Int32)instrument.Fields[1];
string sell = (string)instrument.Fields[2];

You can also use GetDouble(), GetInt(), GetString() methods of ObjectTable class

double price = instrument.Fields.GetDouble(0);

int size = instrument.Fields.GetInt(1);
string sell = instrument.Fields.GetString(2);

How to define a number of digits displayed in instrument prices

You may want to show prices in different formats depending on instrument type. For example you may
want to display six digits after the dot for forex instruments.

You can use Instrument.PriceFormat property to set a format string used in GUI or in your own
applications to display instrument prices. Default value of this property is “F2”, which means two digits
after the dot. The following code line changes it to four digits after the dot for MSFT instrument.

Instrument instrument = InstrumentManager.Instruments["MSFT"];

 instrument.PriceFormat = "F4";

Actually the price format parameter is a standard C# ToString() numeric format string, so that you can
follow C# rules to display instrument prices as you need:

http://msdn.microsoft.com/en-us/library/0c899ak8(v=vs.110).aspx

How to develop and register a custom object streamer

In order to demonstrate how to store custom objects in SmartQuant Framework, we create custom
FIXField class that contains an integer FIX tag and a string value, and a simple FIXMessage class, which is
just a dictionary containing FIXField objects.

We also create corresponding streamers for these classes, FIXFieldStreamer and FIXMessageStreamer
and register these streamers in the framework.xml configuration file.

FIXField class

using System;

namespace CustomStreamer
{
public class FIXField
{
int tag;
string value;

public int Tag

{
get { return tag; }
}

public string Value

{
get { return value; }
}

public FIXField(int tag, string value)

{
this.tag = tag;
this.value = value;
}

public override string ToString()

{
return tag.ToString() + " " + value;
}
}
}

FIXMessage class

using System;
using System.Collections.Generic;

namespace CustomStreamer
{
public class FIXMessage : Dictionary<int, FIXField>
{
public void Add(FIXField field)
{
Add(field.Tag, field);
}

public void Add(int tag, string value)

{
Add(new FIXField(tag, value));
}
}
}

FIXFieldStreamer class

using System;
using System.IO;

using SmartQuant;

namespace CustomStreamer
{
class FIXFieldStreamer : ObjectStreamer
{
public FIXFieldStreamer()
{
typeId = 201;
type = typeof(FIXField);
}

public override object Read(BinaryReader reader)

{
return new FIXField(reader.ReadInt32(), reader.ReadString());
}

public override void Write(BinaryWriter writer, object obj)

{
FIXField field = (FIXField)obj;

writer.Write(field.Tag);
writer.Write(field.Value);
}
}
}

FIXMessageStreamer class

using System;
using System.Collections.Generic;
using System.IO;

using SmartQuant;

namespace CustomStreamer
{
class FIXMessageStreamer : ObjectStreamer
{
public FIXMessageStreamer()
{
typeId = 202;
 type = typeof(FIXMessage);
}

public override object Read(BinaryReader reader)

{
FIXMessage message = new FIXMessage();

Int32 count = reader.ReadInt32();

for(int i=0;i<count;i++)
{
FIXField field = (FIXField)streamerManager.Deserialize(reader);

message.Add(field);
}

return message;
}

public override void Write(BinaryWriter writer, object obj)

{
FIXMessage message = (FIXMessage)obj;

writer.Write(message.Count);

foreach (FIXField field in message.Values)

streamerManager.Serialize(writer, field);
}
}
}

Now we register our custom streamers in the framework by adding the following lines in the Streamers
section of the framework.xml configuration file:

<Streamer>
<TypeName>CustomStreamer.FIXFieldStreamer, CustomStreamer</TypeName>
</Streamer>
<Streamer>
<TypeName>CustomStreamer.FIXMessageStreamer, CustomStreamer</TypeName>
</Streamer>

How to access n-bars ago bar in a bar series

You can simply use BarSeries.Ago(n) method, which is equivalent to BarSeries[BarSeries.Count – 1 – n].

How to work with multiple time frames

In this FAQ we will modify SMA Crossover example so that instead of crossing two SMA with different
lengths of 1 min bar series, it will cross SMA of 1 min and 5 min bar series.
First of all we change Scenario.cs file so that the BarFactory builds 1 min and 5 min bars on the fly from
trade data.

BarFactory.Add(instrument1, BarType.Time, 60);

BarFactory.Add(instrument2, BarType.Time, 60);

BarFactory.Add(instrument1, BarType.Time, 300);

BarFactory.Add(instrument2, BarType.Time, 300);

Then we can modify MyStrategy.cs file.

Define two BarSeries, bars1min and bars5min. We will use these series to store bars of different time
frames.

BarSeries bars1min;
BarSeries bars5min;

Create BarSeries objects in OnStrategyStart method and use them as input series of corresponding SMA
indicators. Note that we use one Length parameter, which we set to 14 in our demo

bars1min = new BarSeries();

bars5min = new BarSeries();

sma1 = new SMA(bars1min, Length);

sma2 = new SMA(bars5min, Length);

Then all we need to do is to add right bars into right series in the OnBar method

if (bar.Size == 60)
bars1min.Add(bar);

if (bar.Size == 300)
bars5min.Add(bar);

Now we are ready to run the strategy. The screenshot below shows strategy chart where you can see
bars of two different time frames as well as SMA indicators and strategy transactions.
How to filter market data and other events

EventManager.Filter can be used to filter (or modify) event stream in the SmartQuant framework. An
event filter is an object of a class derived from the EventFilter class.

Here is an example of a simple event filter that filters out of session market data events.

using System;

using SmartQuant;

namespace OpenQuant
{
public class SessionEventFilter : EventFilter
{
private TimeSpan time1;
private TimeSpan time2;

public SessionEventFilter(Framework framework, TimeSpan time1, TimeSpan time2)

: base(framework)
{
this.time1 = time1;
this.time2 = time2;
}

public override Event Filter(Event e)

{
if (e.TypeId == EventType.Trade)
{
if (e.DateTime.TimeOfDay < time1 || e.DateTime.TimeOfDay > time2)
return null;
else
return e;
}
else if (e.TypeId == EventType.Bar)
{
Bar bar = (Bar)e;
 if (bar.OpenDateTime.TimeOfDay < time1 || bar.CloseDateTime.TimeOfDay >
time2)
return null;
else
return bar;
}

return e;
}
}
}

Then you can write in the scenario file or in your program.

EventManager.Filter = new SessionEventFilter(framework, sessionTime1, sessionTime2);

How to develop complex custom indicators

All you need to do to develop a simple custom indicator is to derive your indicator class from Indicator
class of SmartQuant Framework and override its Calculate(int index) method.

OpenQuant 2014 installation includes a demo solution with several indicators that you can use as a
template to develop your own custom indicators.

Below we publish source code of EWM (Exponential Weighted Mean) indicator which you can study as a
reference and which we will use in this chapter to develop a complex indicator.

for

(see http://en.wikipedia.org/wiki/Moving_average)

using System;

using SmartQuant;

namespace SmartQuant.Indicators
{
/// <summary>
/// Exponential Weighted Mean (EWM)
/// </summary>
public class EWM : Indicator
{
double length;
double initValue;

public double Length

{
get { return length; }
}

public double InitValue

{
get { return initValue; }
}

public EWM(ISeries input, double length, double initValue = 0)

: base(input)
 {
this.length = length;
this.initValue = initValue;
}

public override void Calculate(int index)

{
if (index > 0)
Add(input.GetDateTime(index), Math.Exp(-1.0 / length) * this[index - 1] +
(1 - Math.Exp(-1.0 / length)) * input[index]);
else
Add(input.GetDateTime(index), initValue);
}
}
}

A complex indicator is an indicator that depends on another indicator. For example a EWV (Exponential
Weighted Volatility) indicator uses EWM (Exponential Weighted Mean) to calculate volatility as

(see http://en.wikipedia.org/wiki/Variance )

In order to understand issues related to the development of such complex indicator, we should
understand how indicators get calculated in the SmartQuant Framework.

An indicator has its input series, which is passed in the indicator constructor. When you create an
indicator its instance is added to the list of indicators of its input series. I.e. when you call new
SMA(barSeries, 14); SMA indicator instance is added to barSeries.Indicators list. When a new bar is
added to the barSeries, the Indicator.Calculate method is called for all indicators in the
barSeries.Indicators list. This means that indicators are updated automatically behind the scene when
new entries are added to their input series. Since Indicator class is derived from TimeSeries class,
Indicator also has a list of Indicators. This means that you can easily construct indicators that use other
indicators as input series (construct indicators on indicators).

Note that indicators are updated one by one in the order in which they were added to the Indicators list
of their input series. This may create problems in situations where you need to update indicators in
certain order.

using System;

using SmartQuant;

namespace SmartQuant.Indicators
{
public class EWV : Indicator
{
double length;
double initValue;

EWM ewm;
EWM ewm2;

TimeSeries input2;
 public double Length
{
get { return length; }
}

public double InitValue

{
get { return initValue; }
}

public EWV(ISeries input, double length, double initValue = 0)

: base(input)
{
this.length = length;
this.initValue = initValue;

ewm = new EWM(input, length);

ewm.AutoUpdate = false;

input2 = new TimeSeries();

ewm2 = new EWM(input2, length);

}

public override void Calculate(int index)

{
ewm.Calculate(index);

input2.Add(input.GetDateTime(index), Math.Pow(input[index], 2));

if (index > 0)
{
Console.WriteLine(ewm2.Last + " " + Math.Pow(ewm.Last, 2));

Add(input.GetDateTime(index), Math.Sqrt(ewm2.Last - Math.Pow(ewm.Last,

2)));
}
else
Add(input.GetDateTime(index), initValue);
}
}
}

How to set parameters for a particular instance of Instrument Strategy

1. Call Strategy.Init() - this creates strategy tree and instances for instruments added in the
Strategy.AddInstrument.

2. Obtain a reference to a particular strategy instance, for example

InstrumentStrategy.GetStrategy("SMACrossover (MSFT)");

3. Cast to your strategy class

4. Set parameters.

Code:

strategy.Init();
((MyStrategy)strategy.GetStrategy("SMACrossover (MSFT)")).Qty = 100;

You can also use Strategy.SetParameter method to avoid casting.

Code:

strategy.GetStrategy("SMACrossover (MSFT)").SetParameter("Qty", 100);

Note that in this case your parameter (field or property) should be marked with [Parameter] attribute in
your strategy code.

Also note that parameter values for parameters marked with [Parameter] attribute get copied among
instances when you call InstrumentStrategy.Init or run the strategy (which calls init behind the scene if
you don't call it in your code).

((MyStrategy)strategy).Qty = 100;

strategy.Init();

or

((MyStrategy)strategy).Qty = 100;

StartStrategy();

sets 100 to Qty property for all instruments (strategy instances).

How to change the FileServer port

It might happen so that FileServer default port (1000) is already in use on your computer. You can
change the port number, which the FileServer uses to accept client connections, by modifying FileServer
configuration file. When you run the FileServer for the first time, it deploys the configuration.xml file
into AppData/Roaming/SmartQuant LTD/FileServer /config directory. You can modify this file to change
the port number

<?xml version="1.0" encoding="utf-8"?>

<Configuration xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Port>245</Port>
</Configuration>

Next time you run the FileServer, it will accept clients on this new port (245).

Don’t forget to change InstrumentFilePort and DataFilePort accordingly in the OpenQuant 2014
configuration file.

<?xml version="1.0" encoding="utf-8"?>

<Configuration xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<IsInstrumentFileLocal>false</IsInstrumentFileLocal>
<InstrumentFileHost>127.0.0.1</InstrumentFileHost>
 <InstrumentFilePort>245</InstrumentFilePort>
<InstrumentFileName>C:\Users\Anton\AppData\Roaming\SmartQuant Ltd\OpenQuant
2014\data\instruments.quant</InstrumentFileName>
<IsDataFileLocal>false</IsDataFileLocal>
<DataFileHost>127.0.0.1</DataFileHost>
<DataFilePort>245</DataFilePort>
<DataFileName>C:\Users\Anton\AppData\Roaming\SmartQuant Ltd\OpenQuant
2014\data\data.quant</DataFileName>

If you use an old version of OpenQuant 2014 and don’t have these lines in your configuration.xml file,
you should add them manually to connect to the FileServer on 245 port.

How to control event bus latency in the real time mode

The Event Dispatcher of the SmartQuant Framework constantly tries to dequeue an event (market data,
execution report and so on) from the Event Bus and pass it to your trading strategy or application. If the
Event Bus contains no events, the bus turns into the idle mode. Such idle mode can be organized in
several ways. The event bus thread can go to sleep for a while, it can spin until it has an event to
dequeue, or it can wait until it gets a notification about a new event added to the bus. This behavior can
be controlled with the EventBus.IdleMode option, which can be Spin, Sleep or Wait.

EventBusIdleMode.Spin adds almost no latency but it eats 100% of one core of your CPU since it
constantly checks for a new event in [while empty do nothing] loop.

EventBusIdleMode.Sleep calls Thread.Sleep(1) and adds 1ms latency if you have a stream of rare events,
but on the other hand it almost completely releases the CPU.

EventBusIdleMode.Wait employs ManualResetEventSlim . As MSDN suggests, ManualResetEventSlim

can be used for better performance when wait times are expected to be very short, and when the event
does not cross a process boundary. ManualResetEventSlim uses busy spinning for a short time while it
waits for the event to become signaled. When wait times are short, spinning can be much less expensive
than waiting by using wait handles. However, if the event does not become signaled within a certain
period of time, ManualResetEventSlim resorts to a regular event handle wait. It adds approximately 40
ns to latency.

EventBusIdleMode.Wait is the default idle mode, which is optimal and adequate for almost every task,
including UHF trading. You can change it to Sleep if you don’t care about millisecond latency but don’t
want to load your CPU. Alternatively, you can change it to Spin if you have a multicore CPU and require
the lowest possible latency.

How to change path to local data files (instrument and market database)

You can configure SmartQuant framework and OpenQuant application by editing configuration.xml file
that can be found in your AppData\Roaming\SmartQuant Ltd\OpenQuant 2014\config folder.
Note that OpenQuant installs this file when you run OpenQuant application for the first time (as well as
demo solutions and GUI settings), so that you should run OpenQuant at least once to be able to find this
file.

<?xml version="1.0" encoding="utf-8"?>

<Configuration xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<IsInstrumentFileLocal>true</IsInstrumentFileLocal>
<InstrumentFileHost>127.0.0.1</InstrumentFileHost>
<InstrumentFilePort>1000</InstrumentFilePort>
<InstrumentFileName>C:\Users\Anton\AppData\Roaming\SmartQuant Ltd\OpenQuant
2014\data\instruments</InstrumentFileName>
<IsDataFileLocal>true</IsDataFileLocal>
<DataFileHost>127.0.0.1</DataFileHost>
<DataFilePort>1000</DataFilePort>
<DataFileName>C:\Users\Anton\AppData\Roaming\SmartQuant Ltd\OpenQuant
2014\data\data</DataFileName>
<DefaultCurrency>USD</DefaultCurrency>
<DefaultExchange>SMART</DefaultExchange>
</Configuration>

Data access settings are particularly interesting for us and we are going to discuss these settings in this
and next chapters.

OpenQuant setup installs instrument definition and market data files into
AppData\Roaming\SmartQuant Ltd\OpenQuant 2014\data folder. These files are instruments.quant and
data.quant. If you want to change location(s) of these files, you can move them to another place on your
computer and then edit <InstrumentFileName> and <DataFileName> entries in the configuration file to
reflect this relocation.

Note that you don’t need to type .quant extension in the instrument.quant and data.quant file names in
the configuration file.

Note that OpenQuant application should be closed when you edit the configuration file, otherwise you
changes will be overridden with the current OpenQuant configuration settings when you close
OpenQuant.

How to do things periodically (on every session open, close and so on)

TimeSpan SessionOpen = new TimeSpan(9, 30, 0);

public override void OnStrategyStart()

{
AddReminder(Clock.DateTime.Date.Add(SessionOpen));
}

public override void OnReminder(DateTime dateTime, object data)

{
// do what you want to do on SessionOpen

....

AddReminder(Clock.DateTime.Date.AddDays(1).Add(SessionOpen));
}

How to change chart attributes

You can change colors, styles and other attributes of objects that you draw on a chart using
corresponding group parameters. Assume you create a group for a bar series to draw it on chart pad 0
using instrument symbol as a selector key (to switch between charts for different instruments). You can
find this code in the SMACrossover demo strategy:

barsGroup = new Group("Bars");

barsGroup.Add("Pad", 0);
barsGroup.Add("SelectorKey", Instrument.Symbol);

Bar series will be drawn with default attributes. You will see a candle chart with white and black candles.

You can add

barsGroup.Add("CandleBlackColor", Color.Green);
barsGroup.Add("CandleWhiteColor", Color.Yellow);

to draw green and yellow candles instead

or change style to bar chart adding

barsGroup.Add("ChartStyle", "Bar");

Then you should see

You can use the following attributes for different drawing objects:

BarSeries

ChartStyle (Bar, Candle, Line)

Color
BarColor
CandleColor
CandleBorderColor
CandleWhiteColor
CandleBlackColor
Width

FillSeries

BuyColor
SellColor
TextEnabled

TickSeries

Style (Line, Circle)

Color
Width
Text (%t – datetime, %p – price, %s - size)
Format (of datetime in Text, default “HH:mm:ss.tt”)

TimeSeries

Style (Line, Bar, Circle)

Color
Width

How to plot bids, asks, trades and bars on the same plot

Define event groups in your strategy

private Group bidsGroup;

private Group asksGroup;
private Group tradeGroup;
private Group barsGroup;

Create these groups in OnStrategyStart

bidsGroup = new Group("Bids");

bidsGroup.Add("Pad", DataObjectType.String, 0);
bidsGroup.Add("SelectorKey", Instrument.Symbol);
bidsGroup.Add("Color", Color.Blue);

asksGroup = new Group("Asks");

asksGroup.Add("Pad", DataObjectType.String, 0);
asksGroup.Add("SelectorKey", Instrument.Symbol);
asksGroup.Add("Color", Color.Red);

tradeGroup = new Group("Trades");

tradeGroup.Add("Pad", DataObjectType.String, 0);
tradeGroup.Add("SelectorKey", Instrument.Symbol);
tradeGroup.Add("Color", Color.Green);
 barsGroup = new Group("Bars");
barsGroup.Add("Pad", DataObjectType.String, 0);
barsGroup.Add("SelectorKey", Instrument.Symbol);

And add to the GroupManager

GroupManager.Add(barsGroup);
GroupManager.Add(bidsGroup);
GroupManager.Add(asksGroup);
GroupManager.Add(tradeGroup);

Note that if you add bar group first, ticks will be plotted on top of bars and vice versa, so the order is
important.

Log asks, bids, trades and bars in the corresponding event handlers in your strategy

protected override void OnBid(Instrument instrument, Bid bid)

{
Log(bid, bidsGroup);
}

protected override void OnAsk(Instrument instrument, Ask ask)

{
Log(ask, asksGroup);
}

protected override void OnTrade(Instrument instrument, Trade trade)

{
Log(trade, tradeGroup);
}

protected override void OnBar(Instrument instrument, Bar bar)

{
Log(bar, barsGroup);
}
How to control reminder event order

In the simulation mode reminders are triggered by time stamps of data events. If you have a data event
with the same datetime as you set in the reminder, there are two possibilities - reminder event can be
emitted before or after this data event. Assume you set a reminder to be fired at 10:30 and you have a
tick (let’s say a bid) coming exactly at 10:30. The framework can process this bid first and you get OnBid
call in your strategy and then your reminder will be executed. Alternatively the framework can execute
your reminder first, call OnReminder in your strategy and then call OnBid.

You can control this order using ReminderOrder property of the EventBus.

Framework.EventBus.ReminderOrder = ReminderOrder.Before; - reminders are emitted before data

events with the same time stamps

Framework.EventBus.ReminderOrder = ReminderOrder.After; - reminders are emitted after data events

with the same time stamps

The framework uses ReminderOrder.Before mode by default.

How to use ExecutionSimulator.Queued property

What potentially may happen if you do something “too fast”, like sending an order and then
replacing/cancelling it in the same OnBar or OnReminder, is that you send an order to the Execution
Simulator, the simulator accepts the order, fills it, and places execution report into the Event Bus queue.
This execution report is in the queue, but not in the Order Manager yet, so that the order still has New
status although it has already been filled in the Execution Simulator. Then you can try to replace/cancel
the order in your strategy but the Execution Simulator rejects your request sending out cancel/replace
reject report.

This is pretty normal and reflects real life. Your order can already be filled on the broker server but you
don’t know about it yet and ask broker to cancel it. Indeed your cancel request will be rejected.

You can control this scenario using ExecutionSimulator.Queued = false. Then your order will be executed
directly without sending reports via EventBus queue.