# MQL5 Calculate lot size for partial close

Hi!

I'm developing a Grid-EA on MQL5, and I'm stuck on a particular problem.

I have the follwing problem to solve and was wondering if you could help me out.
This is the problem I'm trying to solve:
Imagine we have have a grid of buy positions:
1. buy position 1 lot
2. buy position 2 lots
3. buy position 4 lots
4. buy positons 8 lots
We have a parameter called

- minimum profit to reduce drawdown (

which is set to 60 (USD) for example.

If the 4. buy position goes >= 60 USD
the EA should partially close the 1. buy position with x lots equivalent to 60 USD
and close (reduce) the 1. buy position to x lots.

The problem I have is calculating the lot size the EA should partially close equal to 60 USD.
I have a solution in code. The problem is, however I try to achieve it I don't seem to do the right calculations because I get a loss after the partial close.

So I guess my lot size is always to big, but I'm not sure.

Here is my approach in code:

```// recovery
// start if x% in drawdown of account balance
double equity = currentAccount.Equity();
double minDrawdown = (currentAccount.Balance() / 100) * InpMinDDForRecoveryStart;
if (currentAccount.Equity() < (currentAccount.Balance() / 100) * InpMinDDForRecoveryStart || InpMinDDForRecoveryStart == 0) {
// check if the last open positions have some profits

CTrade trade;
CPositionInfo position;

// buy positions
if (countBuyPositions() > 1) {

for (int i = 0; i < countBuyPositions(); i++) {

position.SelectByIndex(i);
ulong ticketCurrentPosition = position.Ticket();
double lotsCurrentPosition = position.Volume();
double lossCurrentPosition = positionProfitByTicket(ticketCurrentPosition, POSITION_TYPE_BUY);
double priceCurrentPosition = position.PriceOpen();

ulong ticketLastPosition = ticketLastPosition(POSITION_TYPE_BUY);

// check if current position is last, then skip
if (ticketCurrentPosition == ticketLastPosition) {
continue;
}

double lastPositionProfit = positionProfitByTicket(ticketLastPosition, POSITION_TYPE_BUY);
// switch to last profit position
position.SelectByTicket(ticketLastPosition);
double priceLastPosition = position.PriceCurrent();

if (lotsCurrentPosition > 0.01 && lastPositionProfit > InpMinProfitToUse) {
// calculate lot for partial close
double tickValue = currentSymbol.TickValue();
double tickSize = currentSymbol.TickSize();
double point = Point();
double digits = Digits();
double deltaVal = deltaValuePerLot(Symbol() );
double deltaPips = deltaToPips(deltaVal);

// get distance between position to close and profit position
double distanceInPoints = MathRound((priceCurrentPosition - priceLastPosition)/SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_SIZE) );

if (distanceInPoints == 0) continue;

double volume = lastPositionProfit/distanceInPoints;

volume = normalizeLots(volume, Symbol() );

// close Profit making position
//trade.PositionClose(ticketLastPosition, InpMaxSlippage);
// close Partial loss making position
trade.PositionClosePartial(ticketCurrentPosition, volume, InpMaxSlippage);

Print("Closed partial position with Profit: " + (lastPositionProfit - lossCurrentPosition) );

} else {
continue;
}```

The question is:

is calculating the lot size like this wrong?

`double volume = lastPositionProfit/distanceInPoints;`

The normalize function is like this (from @whroeder1)

```double normalizeLots(double lots, string pair=""){
if (pair == "") pair = Symbol();
double  lotStep     = SymbolInfoDouble(pair, SYMBOL_VOLUME_STEP);

return MathRound(lots/lotStep) * lotStep;

}```

Thanks in advance for your help!

Best regards

Did you manage to find the solution to this . I am facing the same issue

Nairam18: The question is:

is calculating the lot size like this wrong?

`double volume = lastPositionProfit/distanceInPoints;`
the EA should partially close the 1. buy position with x lots equivalent to 60 USD
1. It is, no conversion factor. Compute lots by OrderClosePrice-OrderOpenPrice (below).

2. Risk depends on your initial stop loss, lot size, and the value of the symbol. It does not depend on margin and leverage. No SL means you have infinite risk. Never risk more than a small percentage of your trading funds, certainly less than 2% per trade, 6% total.

1. You place the stop where it needs to be — where the reason for the trade is no longer valid. E.g. trading a support bounce the stop goes below the support.

2. AccountBalance * percent/100 = RISK = OrderLots * (|OrderOpenPrice - OrderStopLoss| * DeltaPerLot + CommissionPerLot) (Note OOP-OSL includes the spread, and DeltaPerLot is usually around \$10/PIP but it takes account of the exchange rates of the pair vs. your account currency.)

3. Do NOT use TickValue by itself - DeltaPerLot and verify that MODE_TICKVALUE is returning a value in your deposit currency, as promised by the documentation, or whether it is returning a value in the instrument's base currency.
MODE_TICKVALUE is not reliable on non-fx instruments with many brokers - MQL4 programming forum (2017)
Is there an universal solution for Tick value? - Currency Pairs - General - MQL5 programming forum (2018)
Lot value calculation off by a factor of 100 - MQL5 programming forum (2019)

4. You must normalize lots properly and check against min and max.

5. You must also check FreeMargin to avoid stop out

Most pairs are worth about \$10 per PIP. A \$5 risk with a (very small) 5 PIP SL is \$5/\$10/5 or 0.1 Lots maximum.

Reason: