Trade management functions and variables

Trade enter commands can receive a trade management function (TMF) as the first argument. A TMF is a function for micro managing the trade. It is repeatedly called until the trade is closed. In most cases it's used for modifying entry, stop, or profit limits in a special way, overriding the standard trailing methods. In live trading and in TICKS mode, a TMF is executed every tick and thus has access to the most recent price quote. When the market is closed and no price ticks are received, TMFs are not executed.

TMFs are also executed at 4 special events in the lifetime of a trade: Right before entering or exiting due to Entry, Stop, or TakeProfit, and right after being closed. Which event it is can be checked in the TMF with the boolean expressions TradeIsEntry, TradeIsStop, TradeIsProfit, TradeIsClosed (described below).

A TMF has the type int and should normally return 0; other return values have a special meaning.  !!  When using a TMF, make sure the function has a return statement with the correct value!

TMF return values:

The return values can be combined by addition. For instance, return value 28 (= 4+8+16) executes the TMF only at the next bar or when Entry, Stop, or TakeProfit was hit, and does not automatically enter or exit in that case.

A a list of up to 8 var variables can be passed as parameters to the TMF, f.i. enterLong(MyTMF, parameter1, parameter2...). They can appear in the argument list of the TMF definition and keep their values during the lifetime of the trade.

Trade-specific variables

In a TMF, in a trade loop, or by directly setting the ThisTrade pointer, the following variables of the selected trade can be accessed:

TradePriceOpen

TradePriceClose

TradeSpread

TradeStrike

TradeUnderlying

TradeRoll

TradeMarginCost

TradeCommission

TradeProfit

TradeUnits

TradeDate

TradeExitDate

TradeMFE

TradeMAE

TradeEntryLimit

TradeStopLimit

TradeStopDiff

TradeProfitLimit

TradeTrailLimit

TradeTrailSlope

TradeTrailStep

TradeTrailLock

Type:

TradeVar[0] .. TradeVar[7]

Type:

TradeLots

TradeLotsTarget

TradeLife

TradeBars

TradeBarOpen

TradeBarClose

TradeContract

TradeID

Type:

TradeIsShort

TradeIsLong

TradeIsContract

TradeIsCall

TradeIsPut

TradeIsAsset

TradeIsPhantom

TradeIsPool

TradeIsVirtual

TradeIsPending

TradeIsMissed

TradeIsUnfilled

TradeIsOpen

TradeIsClosed

TradeIsExpired

TradeIsNewBar

TradeIsEntry

TradeIsStop

TradeIsProfit

Type:

TradeAlgo

TradeAsset

Type:

ThisTrade

Remarks:

•  !!  All trade variables listed above can only be accessed inside a TMF, inside a trade enumeration loop, or when ThisTrade was explicitely set to a valid TRADE* pointer. In all other cases they have invalid content. If ThisTrade was set from enterLong/Short, check the pointer for nonzero before accessing a trade variable. Any access to a trade variable will cause an invalid pointer crash when the ThisTrade pointer is 0.
• Asset specific variables, such as PIP, PIPCost etc. are automatically set to the trade asset during a TMF or a trade enumeration loop, unless you explicitely prevent this by switching to a different asset. For using algorithm specific variables in a TMF, such as trade statistics or AlgoVar, the algo function must be called in the TMF (see example).
•  !!  Most trade variables are of type float. They are normally automatically converted to var in lite-C, exept for functions that have no fixed variable type such as printf(). For directly printing trade variables, place a (var) before them in the printf parameter list to convert them to var.
•  !!  Make sure that all TMFs return a value. Ending the TMF function without a return value can cause wrong or random trading behavior.
• The TICKS flag is often required for testing TMFs that use intrabar prices or enter / exit trades.
• TMFs can open new trades with enterLong/Short. However be careful when assigning them the same TMF: mistakes in entry conditions can lead to an endless loop of entering new trades. Exit a trade by returning 1, rather than calling exitTrade.
• Trades can be entered and exited by returning 1 or 2 even during the weekend or holidays when price quotes arrive and the BR_SLEEP flag is not set.
• TMFs can have a heavy performance footprint. For tasks that are not related to a certain trade, using a tick function is preferable to a TMF. For scanning through multiple trades, a for(open_trades) loop is preferable to a TMF.
• Functions that affect the program flow - like loop, optimize, etc. - can not be called in a TMF. Data series cannot be created in a TMF, and indicators that create data series can not be called; but series and indicator values can be evaluated through global variables or asset/algo specific variables. Static series can be shifted in a TMF using the shift function.
• The current candle is incomplete within a TMF, so its range and height normally deviates from the other candles. The price functions return different values because they get their open, high, and low prices from the incomplete candle.

Examples (see also trade loops):

// TMF for adaptive entry / exit by moving OrderLimit every 30 seconds 
int AdaptLimit()
{
  if(TradeIsMissed) {
    var Step = max(0.2*Spread,PIP/2);
    OrderDelay = 30;   // try again in 30 seconds
    if(!TradeIsOpen) { // entry limit
      if(TradeIsLong) {
        if(OrderLimit > TradePriceOpen) 
          return 1;   // cancel trade
        OrderLimit += Step;  // adapt limit
      } else { // short
        if(OrderLimit < TradePriceOpen-Spread) 
          return 1;   
        OrderLimit -= Step;
      }
      OrderLimit = roundto(OrderLimit,PIP/2);
      return 2+16; // trigger tmf at next event
    } else { // exit limit
      if(TradeIsLong)
        OrderLimit -= Step;
      else
        OrderLimit += Step;
      OrderLimit = roundto(OrderLimit,PIP/2);
      return 1+16; // trigger tmf at next event
    }
  }
  return 16; // trigger tmf at next event
}

// TMF that moves the stop level in a special way 
int TrailingStopLong()
{
// adjust the stop only when the trade is in profit.
  if(TradeIsOpen and TradeProfit > 0)
// place the stop at the lowest bottom of the last 3 candles
    TradeStopLimit = max(TradeStopLimit,LL(3));
// plot a line to make the stop visible in the chart
  plot("Stop",TradeStopLimit,MINV,BLACK);
// return 0 to let Zorro check the stop/profit limits
  return 0;
}

function run()
{
  set(TICKS);  // normally needed for TMF
  ...
  enterLong(TrailingStopLong);
}

// print profit of every trade
...
for(open_trades)
  printf("\n%s profit %.2f",Asset,(var)TradeProfit);
...

// TMF that opens an opposite trade when stopped out,
// and opens a new trade when profit target is reached (Zorro 1.22 and above)
int ReverseAtStop()
{
  if(TradeIsStop) { // stop loss hit?
    if(TradeIsShort)
      enterLong(ReverseAtStop); // enter opposite trade
    else 
      enterShort(ReverseAtStop);
  }
  if(TradeIsProfit) { // profit target hit?
    if(TradeIsShort)
      enterShort(ReverseAtStop); // enter same trade again
    else 
      enterLong(ReverseAtStop);
  }
// call the TMF at stop loss / profit target only  
  return 16;
}

function run()
{
  set(TICKS);  // normally needed for TMF
  Weekend = 3; // don't run TMF at weekend

  Stop = 100*PIP;
  TakeProfit = 100*PIP;
  if(Bar == LookBack) // enter the first trade directly at the first bar
    enterLong(ReverseAtStop);
}

// TMF with parameters, for a Chandelier Stop
int Chandelier(var TimePeriod,var Multiplier)
{
  if(TradeIsLong)
    TradeStopLimit = max(TradeStopLimit,ChandelierLong(TimePeriod,Multiplier));
  else
    TradeStopLimit = min(TradeStopLimit,ChandelierShort(TimePeriod,Multiplier));
  return 8; // only update once per bar
}

function run()
{
  ...
  if(LongSignal) {
    Stop = ChandelierLong(22,3);
    enterLong(Chandelier,22,3);
  }
  ...
}

See also: