public decimal Adjust(Position p)
{
decimal pl = 0;
if (_positions.ContainsKey(p.FullSymbol))
{
// adjust
pl = _positions[p.FullSymbol].Adjust(p);
}
else
{
_positions.Add(p.FullSymbol, p);
}
_closedpl += pl;
return pl;
}
private void ClientGotInitialPosition(Position obj)
{
System.Windows.Application.Current.Dispatcher.Invoke(() =>
{
if (_positiontracker.IsTracked(obj.FullSymbol))
{
int pos = PositionTable.Select(row => row.Symbol).ToList().IndexOf(obj.FullSymbol); // should exist
PositionTable[pos].AvgPrice = obj.AvgPrice;
PositionTable[pos].Size = obj.Size;
PositionTable[pos].ClosePL = obj.ClosedPL;
PositionTable[pos].OpenPL = obj.OpenPL;
}
else
{
int count = PositionTable.Count;
// ?? A first chance exception system notsupportedexception presentationframework dll ??
PositionTable.Add(new PositionEntry(count, obj.FullSymbol, obj.AvgPrice, obj.Size, obj.ClosedPL, obj.OpenPL));
}
});
_positiontracker.Adjust(obj);
}
/// <summary>
/// Provides an offsetting price from a position.
/// For profit taking
/// </summary>
/// <param name="p">Position</param>
/// <param name="offset">Offset amount</param>
/// <returns>Offset price</returns>
public static decimal OffsetPrice(Position p, decimal offset) { return OffsetPrice(p.AvgPrice, p.isLong, offset); }
void Adjust(Position p)
{
if (_positions.ContainsKey(p.FullSymbol))
{
Position o = _positions[p.FullSymbol];
o.Adjust(p);
_positions[p.FullSymbol] = o;
}
else
{
_positions.Add(p.FullSymbol, p);
}
}
/// <summary>
/// must send new positions here (eg from GotPosition on Response)
/// </summary>
/// <param name="p"></param>
public void Adjust(Position p)
{
// did position exist?
bool exists = !_pt[p.symbol].isFlat;
if (exists)
debug(p.symbol + " re-initialization of existing position");
if (exists && ShutdownOnReinit)
{
// get offset
OffsetInfo oi = GetOffset(p.symbol);
// disable it
oi.ProfitPercent = 0;
oi.StopPercent = 0;
// save it
SetOffset(p.symbol, oi);
// cancel existing orders
CancelAll(p.symbol);
// stop processing
return;
}
// update position
_pt.Adjust(p);
// if we're flat, nothing to do
if (_pt[p.symbol].isFlat)
{
debug(p.symbol + " initialized to flat.");
// cancel pending offsets
CancelAll(p.symbol);
// reset offset state but not configuration
SetOffset(p.symbol, new OffsetInfo(this[p.symbol]));
return;
}
// do we have events?
if (!HasEvents()) return;
// do update
doupdate(p.symbol);
}
public override void GotPosition(Position p)
{
if (_symbols.Contains(p.FullSymbol))
_positiontracker.Adjust(p);
}
private void ClientGotInitialPosition(Position obj)
{
foreach (StrategyItem si in _strategyitemlist)
{
si.S.GotPosition(obj);
}
}
// triggered by reqAccountUpdate(true, null) called in Start()
public virtual void updatePortfolio(Contract contract, int position, double marketPrice, double marketValue,
double averageCost, double unrealisedPNL, double realisedPNL, string accountName)
{
Position pos = new Position();
pos.FullSymbol = ContractToSecurityFullName(contract);
pos.Size = position;
// STK averageCost is its unit price
// FUT averageCost is its unit price * multiplier
int multiplier = Security.GetMultiplierFromFullSymbol(pos.FullSymbol);
//pos.AvgPrice = pos.FullSymbol.Contains("STK") ? (decimal)averageCost :
// ((position == 0) ? (decimal)averageCost : (decimal)(averageCost/position/multiplier));
pos.AvgPrice = (decimal)(averageCost / multiplier);
pos.ClosedPL = (decimal)realisedPNL;
pos.OpenPL = (decimal)unrealisedPNL;
pos.Account = Account;
// If exists, don't trigger gotPosition
if (_symbolToPosition.ContainsKey(pos.FullSymbol))
{
_symbolToPosition[pos.FullSymbol] = pos;
}
else
{
_symbolToPosition.Add(pos.FullSymbol, pos);
OnGotPosition(pos);
}
}
public MarketOrderFlat(Position p) : this(p, 0) { }
/// <summary>
/// Generate a stop order for a position, at a specified per-share/contract price
/// </summary>
/// <param name="p">your position</param>
/// <param name="offset">how far away stop is</param>
/// <param name="percent">what percent of position to close</param>
/// <param name="normalizesize">whether to normalize size to even-lots</param>
/// <param name="MINSIZE">size of an even lot</param>
/// <returns></returns>
public static Order PositionStop(Position p, decimal offset, decimal percent, bool normalizesize, int MINSIZE)
{
Order o = new Order();
if (!p.isValid || p.isFlat) return o;
decimal price = Calc.OffsetPrice(p, offset * -1);
int size = percent == 0 ? 0 : (!normalizesize ? (int)(p.FlatSize * percent) : Calc.Norm2Min(p.FlatSize * percent, MINSIZE));
o = new StopOrder(p.FullSymbol, p.isLong ? -size : size, price);
return o;
}
/// <summary>
/// get a stop order for a position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionStop(Position p, OffsetInfo offset) { return PositionStop(p, offset.StopDist, offset.StopPercent, offset.NormalizeSize, offset.MinimumLotSize); }
/// <summary>
/// Generate a stop order for a position, at a specified per-share/contract price
/// </summary>
/// <param name="p">your position</param>
/// <param name="offset">how far away stop is</param>
/// <param name="percent">what percent of position to close</param>
/// <returns></returns>
public static Order PositionStop(Position p, decimal offset, decimal percent) { return PositionStop(p, offset, percent, false, 1); }
/// <summary>
/// get profit order for given position given offset information
/// </summary>
/// <param name="p"></param>
/// <param name="offset"></param>
/// <returns></returns>
public static Order PositionProfit(Position p, OffsetInfo offset) { return PositionProfit(p, offset.ProfitDist, offset.ProfitPercent, offset.NormalizeSize, offset.MinimumLotSize); }
/// <summary>
/// Defaults to 100% of position at target.
/// </summary>
/// <param name="p">your position</param>
/// <param name="offset">your target</param>
/// <returns>profit taking limit order</returns>
public static Order PositionProfit(Position p, decimal offset) { return PositionProfit(p, offset, 1, false, 1); }
// returns any closed PL calculated on position basis (not per share)
/// <summary>
/// Adjusts the position by applying a new position.
/// </summary>
/// <param name="pos">The position adjustment to apply.</param>
/// <returns></returns>
public decimal Adjust(Position pos)
{
if ((_fullsymbol!="") && (this._fullsymbol != pos._fullsymbol)) throw new Exception("Failed because adjustment symbol did not match position symbol");
if (_acct == DefaultSettings.DefaultAccount) _acct = pos.Account;
if (_acct != pos.Account) throw new Exception("Failed because adjustment account did not match position account.");
if ((_fullsymbol=="") && pos.isValid) _fullsymbol = pos._fullsymbol;
if (!pos.isValid) throw new Exception("Invalid position adjustment, existing:" + this.ToString() + " adjustment:" + pos.ToString());
decimal pl = 0;
if (! pos.isFlat)
{
bool oldside = isLong;
pl = Calc.ClosePL(this, pos.ToTrade());
if (this.isFlat) this._avgprice = pos.AvgPrice; // if we're leaving flat just copy price
else if ((pos.isLong && this.isLong) || (!pos.isLong && !this.isLong)) // sides match, adding so adjust price
this._avgprice = ((this._avgprice * this._size) + (pos.AvgPrice * pos.Size)) / (pos.Size + this.Size);
this._size += pos.Size; // adjust the size
if (oldside != isLong) _avgprice = pos.AvgPrice; // this is for when broker allows flipping sides in one trade
if (this.isFlat) _avgprice = 0; // if we're flat after adjusting, size price back to zero
_closedpl += pl; // update running closed pl
return pl;
}
_openpl = Calc.OpenPL(pos.AvgPrice, this);
return pl;
}
public MarketOrderFlat(Position p, long id) : base(p.FullSymbol, p.FlatSize, id) { }
/// <summary>
/// this must be called once per position tracker, for each position update.
/// if you are using your own position tracker with this trailing stop(eg from offset tracker, or somewhere else)
/// you only need to adjust it once, so if you adjust it directly you don't need to call again here.
/// </summary>
/// <param name="p"></param>
public void Adjust(Position p)
{
_pt.Adjust(p);
}
public MarketOrderFlat(Position p, decimal percent, bool normalizeSize, int MinimumLotSize) :
this(p, percent, normalizeSize, MinimumLotSize, 0) { }
void OnGotPosition(Position p)
{
if (GotPositionDelegate != null)
GotPositionDelegate(p);
}
public MarketOrderFlat(Position p, decimal percent, bool normalizeSize, int MinimumLotSize, long id) :
base(p.FullSymbol, normalizeSize ? Calc.Norm2Min((decimal)percent * p.FlatSize, MinimumLotSize) : (int)(percent * p.FlatSize), id) { }
void doupdate(string sym)
{
// is update ignored?
if (IgnoreUpdate(sym)) return;
// wait till next tick if we send cancels
bool sentcancel = false;
// get our offset values
OffsetInfo off = GetOffset(sym);
// get position
Position p = new Position(_pt[sym]);
// if we're flat, nothign to do
if (p.isFlat) return;
// see whats current
bool cprofit = off.isProfitCurrent(p);
bool cstop = off.isStopCurrent(p);
// if not current, mark for update
bool updateprofit = !cprofit;
bool updatestop = !cstop;
// if we're up to date then quit
if (!updatestop && !updateprofit) return;
// see if we have stop update
if ((updatestop && off.hasStop && !CancelOnce)
|| (updatestop && off.hasStop && CancelOnce && !off.StopcancelPending))
{
// notify
if (!off.StopcancelPending)
debug(string.Format("attempting stop cancel: {0} {1}", sym, off.StopId));
// cancel existing stops
cancel(off.StopId);
// mark cancel pending
off.StopcancelPending = true;
// mark as sent
sentcancel |= true;
}
// see if we have profit update
if ((updateprofit && off.hasProfit && AllowSimulatenousCancels) ||
(updateprofit && off.hasProfit && AllowSimulatenousCancels && !sentcancel))
{
if (!CancelOnce || (CancelOnce && !off.ProfitcancelPending))
{
// notify
if (!off.ProfitcancelPending)
debug(string.Format("attempting profit cancel: {0} {1}", sym, off.ProfitId));
// cancel existing profits
cancel(off.ProfitId);
// mark cancel pending
off.ProfitcancelPending = true;
// mark as sent
sentcancel |= true;
}
}
// wait till next tick if we sent cancel
if (sentcancel && WaitAfterCancel)
return;
bool sentorder = false;
// send stop first
if (!off.hasStop)
{
// since we have no stop, it's cancel can't be pending
off.StopcancelPending = false;
// get new stop
Order stop = Calc.PositionStop(p, off.StopDist, off.StopPercent, off.NormalizeSize, off.MinimumLotSize);
// mark size
off.SentStopSize = stop.OrderSize;
// if it's valid, send and track
if (stop.IsValid)
{
stop.Id = Ids.NextOrderId;
off.StopId = stop.Id;
SendOrderEvent(stop);
// notify
debug(string.Format("sent new stop: {0} {1}", stop.Id, stop.ToString(DebugDecimals)));
sentorder = true;
}
else if (_verbdebug)
{
debug(sym + " invalid stop: " + stop.ToString(DebugDecimals));
}
}
if ((!off.hasProfit && AllowSimulatenousOrders) || (!off.hasProfit && !AllowSimulatenousOrders && !sentorder))
{
// since we have no stop, it's cancel can't be pending
off.ProfitcancelPending = false;
// get new profit
Order profit = Calc.PositionProfit(p, off.ProfitDist, off.ProfitPercent, off.NormalizeSize, off.MinimumLotSize);
// mark size
off.SentProfitSize = profit.OrderSize;
// if it's valid, send and track it
if (profit.IsValid)
{
profit.Id = Ids.NextOrderId;
off.ProfitId = profit.Id;
SendOrderEvent(profit);
// notify
debug(string.Format("sent new profit: {0} {1}", profit.Id, profit.ToString(DebugDecimals)));
sentorder = true;
}
else if (_verbdebug)
{
debug(sym + " invalid profit: " + profit.ToString(DebugDecimals));
}
}
// make sure new offset info is reflected
SetOffset(sym, off);
}
/// <summary>
/// called when a position update is received (usually only when the strategy is initially loaded)
/// </summary>
/// <param name="p"></param>
public virtual void GotPosition(Position p)
{
}
void _backtestengine_GotFillEvent(Trade t)
{
_tradelist.Add(t);
Position mypos = new Position(t);
decimal closepnl = 0;
decimal closepoint = 0;
if (!_positionlist.TryGetValue(t.FullSymbol, out mypos))
{
mypos = new Position(t);
_positionlist.Add(t.FullSymbol, mypos);
}
else
{
closepoint = Calc.ClosePT(mypos, t);
closepnl = mypos.Adjust(t);
_positionlist[t.FullSymbol] = mypos;
}
System.Windows.Application.Current.Dispatcher.Invoke(() =>
{
_positiontable.Rows.Add(t.TradeTime.ToString(), mypos.FullSymbol, mypos.Size, mypos.AvgPrice.ToString(_dps), closepnl.ToString("C2"), closepoint.ToString(_dps));
_filltable.Rows.Add(t.TradeTime.ToString(), t.FullSymbol, t.TradeSize, t.TradePrice.ToString(_dps), t.Id);
});
}
public static Position Deserialize(string msg)
{
string[] r = msg.Split(',');
string sym = r[0];
decimal price = Convert.ToDecimal(r[1], System.Globalization.CultureInfo.InvariantCulture);
int size = Convert.ToInt32(r[2]);
decimal cpl = Convert.ToDecimal(r[4], System.Globalization.CultureInfo.InvariantCulture);
string act = r[5];
Position p = new Position(sym,price,size,cpl,act);
return p;
}
public void GotPosition(Position p) { Adjust(p); }
public static string Serialize(Position p)
{
string[] r = new string[] {
p._fullsymbol,
p.AvgPrice.ToString("F2", System.Globalization.CultureInfo.InvariantCulture),
p.Size.ToString("F0", System.Globalization.CultureInfo.InvariantCulture),
p.ClosedPL.ToString("F2", System.Globalization.CultureInfo.InvariantCulture),
p.Account
};
return string.Join(",", r);
}
public override void GotPosition(Position p)
{
Adjust(p);
}
public Position(Position p) : this(p._fullsymbol, p.AvgPrice, p.Size, p.ClosedPL, p.Account) { }
void _client_GotPositionDelegate(Position obj)
{
_eventAggregator.GetEvent<InitialPositionEvent>().Publish(obj);
}
/// <summary>
/// Gets the closed PL on a position basis, the PL that is registered to the account for the entire shares transacted.
/// </summary>
/// <param name="existing">The existing position.</param>
/// <param name="closing">The portion of the position being changed/closed.</param>
/// <returns></returns>
public static decimal ClosePL(Position existing, Trade adjust)
{
int closedsize = Math.Abs(adjust.TradeSize) > existing.UnsignedSize ? existing.UnsignedSize : Math.Abs(adjust.TradeSize);
return ClosePT(existing, adjust) * closedsize * Security.GetMultiplierFromFullSymbol(adjust.FullSymbol);
}