Trade management functions (TMF)

Trade enter commands can receive the name of a trade management function (TMF) as the first argument: enterLong(MyTMF, ...);. Alternatively, a user function named manage can be defined as a global TMF for all entered trades:

int manage()

A TMF is a function for micro managing the trade. It is triggered for any open or pending trade at any price tick or price change of the traded asset. In most cases it's used for modifying entry, stop, or profit limits in a special way, thus overriding the standard trailing methods. Since a TMF runs at every tick, it 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 special events in the lifetime of a trade: Right before entering or exiting due to an Entry, Stop, or TakeProfit limit, 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).

If the TMF is passed to an enter command, it can receive up to 8 additional var parameters following the function name: enterLong(MyTMF, parameter1, parameter2...). They must also appear in the function's parameter list and keep their values during the lifetime of the trade. The alternative global manage function has no parameters.

A TMF has the return type int and should normally return 0; other return values have a special meaning:

TMF return values

The return values can be combined by addition. For instance, return 28  (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.   !!  When using a TMF, make sure the function has a return statement with the correct value!
 

Trade variables

In a selected trade, the variables listed below available for evaluation and partially for modification. Trades are automatically selected in a TMF or in a trade loop. They can also be selected by setting the ThisTrade pointer, f.i. with ThisTrade = enterLong();. In this case check if ThisTrade is nonzero, since accessing a variable of a nonexisting trade will cause Error 111. Without a selected trade, i.e. outside a TMF or trade enumeration loop and with no set ThisTrade pointer, trade variables have no meaning.

TradePriceOpen

TradeFill

TradePriceClose

TradeValue

TradeSpread

TradeStrike

TradeUnderlying

TradeRoll

TradeMarginCost

TradeCommission

TradeProfit

TradeDir

TradeUnits

TradeDate

TradeExitDate

TradeMFE

TradeMAE

TradeEntryLimit

TradeStopLimit

TradeStopDiff

TradeProfitLimit

TradeTrailLimit

TradeTrailSlope

TradeTrailStep

TradeTrailLock

Type:

TradeVar[0] .. TradeVar[7]

TradeStr[0] .. TradeStr[7]

TradeInt[0] .. TradeInt[15]

Type:

TradeLots

TradeLotsTarget

TradeLife

TradeBars

TradeBarOpen

TradeBarClose

TradeContract

TradeID

Type:

TradeUUID

TradeAlgo

TradeAsset

Type:

TradeIsShort

TradeIsLong

TradeIsContract

TradeIsCall

TradeIsPut

TradeIsAsset

TradeIsPhantom

TradeIsPool

TradeIsVirtual

TradeIsPending

TradeIsMissed

TradeIsOpen

TradeIsClosed

TradeIsExpired

TradeIsNewBar

TradeIsEntry

TradeIsStop

TradeIsProfit

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 no or 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 or not set.
• 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 for calculating the fill amount of a GTC trade from the broker position.
// No other trade with the same asset must be open.
int adaptFill()
{
  if(Live && TradeLots < TradeLotsTarget) {
    TradeLots = (int)brokerCommand(GET_POSITION,SymbolTrade);
    return 0;
  } else
    return 16;
}

// TMF that moves the stop level in a special way 
int trailStopLong()
{
// 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(trailStopLong);
}

// 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 Factor)
{
  if(TradeIsLong)
    TradeStopLimit = max(TradeStopLimit,ChandelierLong(TimePeriod,Factor));
  else
    TradeStopLimit = min(TradeStopLimit,ChandelierShort(TimePeriod,Factor));
  return 8; // only update once per bar
}

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

See also: