mql5/Experts/MartinEffective3.mq5

//+------------------------------------------------------------------+
//|                                                       Grid_2.mq5 |
//|                                                             AK47 |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "AK47"
#property link      "https://www.mql5.com"
#property version   "1.00"

///////INCLUDE//////////

#include <Trade\Trade.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Arrays\ArrayDouble.mqh>
//#include <News.mqh>
//#include <Time.mqh>
////////GLOBALS//////////////

input double   FixedLot=0.01;    // Fixed Lot
input double   fractionToClose = 0.85;    // Fraction of Open Positions to close
input double   TakeProfitFactor=0;
input double   BiasFactor=0;
input ushort   Grid=300;   // Grid Distance

input double   equityTSLActive = 5; // Equity stoploss trail activation in percent
input double   equityTSL       = 5; // Equity stoploss trail percent

//input double   CloseTreshold=1.05;
//input double   FreeMarginThreshold=0.3;
//input double   EquityStopLossPercent=0.9;
input int      PositionsThreshold=2;
input int      MALength = 11;
input int      MALength2 = 200;
input double   Grid_mul = 1, Vol_Mul=1.618;

input ENUM_TIMEFRAMES  TimeFrame = PERIOD_H1;
input ENUM_TIMEFRAMES  UpdateTimeFrame = PERIOD_H1;

input int GMTstartHour = 8;
input int GMTendHour = 14;


////////////CLASSES////////////////////

CTrade trade;
CDealInfo deal;
CPositionInfo PosInfo;
CArrayDouble List;
CAccountInfo Account;
COrderInfo OrdInfo;
//CNews News;
//CTime Time;

//////////VARIABLES/////////////
double      MAHigh[], MAHighHandle,
            MALow[], MALowHandle,
            MA[], MAHandle, VPHandle,
            MAHigh2[], MAHighHandle2,
            MALow2[], MALowHandle2,
            MA2[], MAHandle2,
            atr[], atrHandle,
            MFI[], MFIHandle,
            stochOscMain[], stochOscSignal[], stochOscHandle;

double   ask, bid,
         //nextUp, nextDown,
         StopLossBuy=0, StopLossSell=0,
         TakeProfitBuy=0, TakeProfitSell=0,
         StartingBalance,
         spread,
         buyFactor, sellFactor,
         Grid_step_buy,
         Grid_step_sell,
         currentGrid,
         nextUpBuy, nextDownBuy,
         nextUpSell, nextDownSell;

int      upCount=0, downCount=0, bars = 0;


double   maxEquity, equityVolume = 1;

string   newGrid, previousGrid;

double      buyVolumeFactor = 1, sellVolumeFactor = 1;

bool activateSL = false;




MqlRates Bar1[], Bar2[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
//      News.LoadHistory();
   StartingBalance = Account.Balance();
   maxEquity = Account.Equity();

//VWMAHandle = iCustom(_Symbol, PERIOD_CURRENT, "\\Indicators\\VWMA.mq5");



   ChartSetSymbolPeriod(0,_Symbol,TimeFrame);

//      MFIHandle = iMFI(_Symbol,PERIOD_D1,5,VOLUME_REAL);
//      stochOscHandle = iStochastic(_Symbol,PERIOD_W1,5,3,3,MODE_SMA,STO_LOWHIGH);

   MAHighHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_HIGH);
   MAHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_CLOSE);
   MALowHandle = iMA(_Symbol,TimeFrame,MALength,0,MODE_EMA,PRICE_LOW);
   MAHighHandle2 = iMA(_Symbol,UpdateTimeFrame,MALength2,0,MODE_EMA,PRICE_HIGH);
   MAHandle2 = iMA(_Symbol,UpdateTimeFrame,MALength2,0,MODE_EMA,PRICE_CLOSE);
   MALowHandle2 = iMA(_Symbol,UpdateTimeFrame,MALength2,0,MODE_EMA,PRICE_LOW);
   atrHandle = iATR(_Symbol,UpdateTimeFrame,MALength);
//VPHandle = iCustom(_Symbol,TimeFrame,"\\Indicators\\Free Indicators\\MarketProfile");

   ArraySetAsSeries(MAHigh,true);
   ArraySetAsSeries(MA,true);
   ArraySetAsSeries(MALow,true);
   ArraySetAsSeries(MAHigh2,true);
   ArraySetAsSeries(MA2,true);
   ArraySetAsSeries(MALow2,true);
   ArraySetAsSeries(atr,true);

   ArraySetAsSeries(Bar1, true);
   ArraySetAsSeries(Bar2, true);

   bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);

//   double Prices[];
//   double Volumes[];
//   double levelstep = 5;
//   CalculateVolumeDistribution(3,levelstep,Volumes,Prices);
//
//   int peaks[];
//   int peak_count =  ArrayPeaks(Prices,peaks,100);
//
//
//   FindIndices((ask+bid)/2,Prices,nextDown,nextUp);

   nextUpBuy   = ask + Grid*_Point;
   nextDownBuy = bid - Grid*_Point;
   nextUpSell   = ask + Grid*_Point;
   nextDownSell = bid - Grid*_Point;



   Print("Buy NextLevelUp: " + nextUpBuy);
   Print("Buy NextLevelDown: " + nextDownBuy);
   Print("Sell NextLevelUp: " + nextUpSell);
   Print("Sell NextLevelDown: " + nextDownSell);
//Print("PeaksCount: " + peak_count);

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//      CloseByWin();
//Trailing();
//breakEven();
//TPmodify();

   MqlDateTime dt;
   datetime gmtTime = TimeGMT(dt);

   bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   spread = ask - bid;


//////////////TP&SL//////////////////////////////////////////

   CopyBuffer(MAHighHandle,0,0,4,MAHigh);
   CopyBuffer(MAHandle,0,0,4,MA);
   CopyBuffer(MALowHandle,0,0,4,MALow);
   CopyBuffer(MAHighHandle2,0,0,4,MAHigh2);
   CopyBuffer(MAHandle2,0,0,4,MA2);
   CopyBuffer(MALowHandle2,0,0,4,MALow2);

   CopyBuffer(stochOscHandle,MAIN_LINE,0,4,stochOscMain);
   CopyBuffer(stochOscHandle,SIGNAL_LINE,0,4,stochOscSignal);

   CopyBuffer(atrHandle,0,0,4,atr);

   CopyRates(_Symbol,TimeFrame,0,10,Bar1);
   CopyRates(_Symbol,UpdateTimeFrame,0,10,Bar2);


//////////////////// Factors //////////////////////////////////

   if(BuyPositionsCount() != 0)
      buyVolumeFactor = MathPow(Vol_Mul,VolumeTotal("Buy")/FixedLot);
   else
      buyVolumeFactor = 1;

   if(SellPositionsCount() != 0)
      sellVolumeFactor = MathPow(Vol_Mul,VolumeTotal("Sell")/FixedLot);
   else
      sellVolumeFactor = 1;


   Grid_step_buy = Grid * pow(Grid_mul,BuyPositionsCount());
   Grid_step_sell = Grid * pow(Grid_mul,SellPositionsCount());

   double buyStopVolume = NormalizeDouble(equityVolume*sellVolumeFactor*FixedLot,2);
   double buyLimitVolume = NormalizeDouble(equityVolume*buyVolumeFactor*FixedLot,2);
   double sellStopVolume = NormalizeDouble(equityVolume*sellVolumeFactor*FixedLot,2);
   double sellLimitVolume = NormalizeDouble(equityVolume*sellVolumeFactor*FixedLot,2);

   double buyTotal = VolumeTotal("Buy");
   double sellTotal = VolumeTotal("Sell");
   double totalRisk = (buyTotal - sellTotal)*100000 * .02 / (Account.Leverage());

   bool exposureSide = (buyTotal >= sellTotal) ? true : false;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

//double buyLimitVolume =    0;
//double sellLimitVolume =   0;



   double Volumes[];
   double Prices[];
   int peaks[];
   int below = 0,above = 0;

//   if(bars < iBars(_Symbol,UpdateTimeFrame))
//     {
//      CalculateVolumeDistribution(5,1*_Point,Volumes,Prices);
//
//      ArrayPeaks(Volumes,peaks,1*_Point);
//
//      FindIndices(ask,Prices,below,above);
//
//
//      Print("above: ", above);
//      Print("below: ", below);
//
//      double PriceLevels[];
//      ArrayResize(PriceLevels,ArraySize(peaks));
//      for(int i=0;i<ArraySize(PriceLevels);i++)
//        {
//         PriceLevels[i] = Prices[peaks[i]];
//        }
//      Print("ARRAY: ");
//      ArrayPrint(PriceLevels);
//
//      DrawHorizontalLines(PriceLevels);
//
//      bars = iBars(_Symbol,UpdateTimeFrame);
//
//      Comment("day: ", dt.day_of_week);
//
//     }




   bool tradetime = ((GMTstartHour < GMTendHour && dt.hour >= GMTstartHour && dt.hour <= GMTendHour) || (GMTstartHour > GMTendHour && dt.hour <= GMTstartHour && dt.hour >= GMTendHour));
   bool tradays =  !((dt.day >= 1 && dt.day <= 7 && dt.day_of_week == 5) || (dt.day >= 10 && dt.day <=13) || (dt.day == 16 && dt.mon == 10));

   if(spread<20*_Point && bars < iBars(_Symbol,TimeFrame))
     {


      double meanBuy = meanEntryPrice("Buy");
      double meanSell = meanEntryPrice("Sell");
      double meanTotal = meanEntryPrice("Total");

      DeleteHorizontalLines();

      DrawHorizontalLines(meanBuy,clrGreen);
      DrawHorizontalLines(meanSell,clrRed);
      DrawHorizontalLines(meanTotal,clrBlue);
      if(exposureSide)
         DrawHorizontalLines(meanTotal - (atr[1] * Account.Equity()/totalRisk),clrYellow);
      if(!exposureSide)
         DrawHorizontalLines(meanTotal - (atr[1] * Account.Equity()/totalRisk),clrMagenta);

      Comment(totalRisk, " /n",     meanBuy, " /n",     meanSell, " /n",     meanTotal);


      if(ask < nextDownBuy) // && !OtherBuyPosition(NULL))   // ||  && BuyPositionsCount() > 0)){
        {
         nextUpBuy   = ask + Grid_step_buy*_Point;
         nextDownBuy = bid - Grid_step_buy*_Point;

         if(Bar2[0].close < MALow2[1])
           {
            nextUpBuy   = ask + BiasFactor*Grid_step_buy*_Point;
            nextDownBuy = bid - BiasFactor*Grid_step_buy*_Point;
           }
         if(tradetime && tradays && ((Bar1[0].close < MA[1] && Bar2[0].close > MA2[1])|| BuyPositionsCount() >= PositionsThreshold))  //
            trade.Buy(buyLimitVolume,_Symbol,0,StopLossBuy,TakeProfitBuy,"BuyLimit");

         if(bid > meanEntryPrice("Sell") - BiasFactor*Grid*_Point)
           {
            //CloseSellPortion(0.01);
           }
        }


      if(ask > nextUpSell)
        {
         nextUpSell   = ask + Grid_step_sell*_Point;
         nextDownSell = bid - Grid_step_sell*_Point;

         if(Bar2[0].close > MAHigh2[1])
           {
            nextUpSell   = ask + BiasFactor*Grid_step_sell*_Point;
            nextDownSell = bid - BiasFactor*Grid_step_sell*_Point;
           }

         if(tradetime && tradays && ((Bar1[0].close >  MA[1]&& Bar2[0].close < MA2[1]) || SellPositionsCount() >= PositionsThreshold))  //
            trade.Sell(sellLimitVolume,_Symbol,0,StopLossSell,TakeProfitSell,"SellLimit");

         if(ask < meanEntryPrice("Buy") + BiasFactor*Grid*_Point)
           {
            //CloseBuyPortion(0.01);
           }
        }



      if(bid > nextUpBuy)// && !OtherBuyPosition(NULL))  // ||!OtherBuyPosition(NULL) && BuyPositionsCount() > 0)){
        {
         if(ask > meanEntryPrice("Buy") + TakeProfitFactor*Grid*_Point && BuyPositionsCount() >= PositionsThreshold)
           {
            CloseBuyPortion(fractionToClose);
           }

         if(ask > meanEntryPrice("Buy") + TakeProfitFactor*Grid*_Point && BuyPositionsCount() >= PositionsThreshold)
           {
            //CloseBuyPortion(fractionToClose);
           }
         nextUpBuy   = ask + Grid_step_buy*_Point;
         nextDownBuy = bid - Grid_step_buy*_Point;
         if(Bar2[0].close < MALow2[1])
           {
            nextUpBuy   = ask + BiasFactor*Grid_step_buy*_Point;
            nextDownBuy = bid - BiasFactor*Grid_step_buy*_Point;
           }
         if(tradetime && tradays && ((Bar1[0].close > MA[1] && Bar2[0].close > MA2[1])|| BuyPositionsCount() >= PositionsThreshold))  // )
            trade.Buy(buyStopVolume,_Symbol,0,StopLossBuy,TakeProfitBuy,"BuyStop");
        }



      if(bid < nextDownSell)// && !OtherSellPosition(NULL)) // || && SellPositionsCount() > 0)){
        {
         if(bid < meanEntryPrice("Sell") - TakeProfitFactor*Grid*_Point && SellPositionsCount() >= PositionsThreshold)
           {
            CloseSellPortion(fractionToClose);
           }
         if(bid < meanEntryPrice("Sell") - TakeProfitFactor*Grid*_Point && SellPositionsCount() >= PositionsThreshold)
           {
            //CloseSellPortion(fractionToClose);
           }
         nextUpSell   = ask + Grid_step_sell*_Point;
         nextDownSell = bid - Grid_step_sell*_Point;
         if(Bar2[0].close > MAHigh2[1])
           {
            nextUpSell   = ask + BiasFactor*Grid_step_sell*_Point;
            nextDownSell = bid - BiasFactor*Grid_step_sell*_Point;
           }
         if(tradetime && tradays && ((Bar1[0].close < MA[1] && Bar2[0].close < MA2[1]) || SellPositionsCount() >= PositionsThreshold))
            trade.Sell(sellStopVolume,_Symbol,0,StopLossSell,TakeProfitSell,"SellStop");

        }


      //////Close on FRIDAYS/////////////

      if(dt.day_of_week == 5 && dt.hour == 20)
        {
         //if(ask > meanEntryPrice("Buy") + TakeProfitFactor*Grid*_Point)
         //   CloseBuyWin();
         //if(bid < meanEntryPrice("Sell") - TakeProfitFactor*Grid*_Point)
         //   CloseSellWin();
         //CloseAllPositions();

        }
      //      if(VolumeTotal("Buy") > 0.2 && dt.day == 5)
      //         CloseBuyLoss();
      //      if(VolumeTotal("Sell") > 0.2 && dt.day == 5)
      //         CloseSellLoss();
      //
      //CloseByWinning();
      bars = iBars(_Symbol,TimeFrame);

     }


//////////////////////CLOSERS//////////////////////////////////////////////

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(Account.Equity() > maxEquity)
     {
      if(VolumeTotal("Total") < 0.05)
         maxEquity = Account.Equity();
      equityVolume = Account.Balance()/StartingBalance;
     }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(Account.Equity() >= (1+equityTSLActive/100)*maxEquity)
     {
      activateSL = true;
      maxEquity = Account.Equity();
     }

   if(activateSL && Account.Equity() <= 1/(1+equityTSL/100)*100*maxEquity)
     {
      activateSL = false;
      CloseAllPositions();
     }


  }
//+------------------------------------------------------------------+
//| Trade function                                                   |
//+------------------------------------------------------------------+
void OnTrade()
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DeleteHorizontalLines(string comment = NULL)
  {
   for(int i = ObjectsTotal(0) - 1; i >= 0; i--)
     {
      string name = ObjectName(0,i);
      if(StringFind(name, "HL_"+comment) == 0)  // If the name starts with "HL_"
        {
         ObjectDelete(0, name);
        }
     }


  }
//+------------------------------------------------------------------+
//| Function to draw horizontal lines at specified price levels      |
//+------------------------------------------------------------------+
void DrawHorizontalLines(double &priceLevels[], color lineColor = clrRed, int lineStyle = STYLE_SOLID, int lineWidth = 1, string comment = NULL)
  {
   int arraySize = ArraySize(priceLevels);
////Print("Array Size: ", arraySize);  // Debugging: Print the size of the array

// Clear existing horizontal lines with the naming pattern "HL_"
   for(int i = ObjectsTotal(0) - 1; i >= 0; i--)
     {
      string name = ObjectName(0,i);
      if(StringFind(name, "HL_"+comment) == 0)  // If the name starts with "HL_"
        {
         ObjectDelete(0, name);
        }
     }

   for(int i = 0; i < arraySize; i++)
     {
      // Normalize the price level
      double normalizedPrice = NormalizeDouble(priceLevels[i], _Digits);

      // Create a unique name for each line
      string lineName = ("HL_"+ comment + DoubleToString(normalizedPrice, _Digits));

      // Check if the line already exists, if not, create it
      if(ObjectFind(0, lineName) == -1)
        {
         // Create a horizontal line
         if(ObjectCreate(0, lineName, OBJ_HLINE, 0, 0, normalizedPrice))
           {
            ////Print("Created line: ", lineName, " at price level: ", normalizedPrice);  // Debugging: Confirm line creation

            // Set line properties
            ObjectSetInteger(0, lineName, OBJPROP_COLOR, lineColor);
            ObjectSetInteger(0, lineName, OBJPROP_STYLE, lineStyle);
            ObjectSetInteger(0, lineName, OBJPROP_WIDTH, lineWidth);
            ObjectSetDouble(0, lineName, OBJPROP_PRICE, normalizedPrice);
           }
         else
           {
            int errorcode = GetLastError();
            ////Print("Failed to create line: ", lineName, " Error: ", errorcode);
            continue;
           }
        }
     }
  }


//+------------------------------------------------------------------+
//| Function to draw horizontal lines at specified price levels      |
//+------------------------------------------------------------------+
void DrawHorizontalLines(double priceLevel, color lineColor = clrRed, int lineStyle = STYLE_SOLID, int lineWidth = 1, string comment = NULL)
  {
////Print("Array Size: ", arraySize);  // Debugging: Print the size of the array


// Normalize the price level
   double normalizedPrice = NormalizeDouble(priceLevel, _Digits);

// Create a unique name for each line
   string lineName = ("HL_"+ comment + DoubleToString(normalizedPrice, _Digits));

// Check if the line already exists, if not, create it
// Create a horizontal line
   if(ObjectCreate(0, lineName, OBJ_HLINE, 0, 0, normalizedPrice))
     {
      ////Print("Created line: ", lineName, " at price level: ", normalizedPrice);  // Debugging: Confirm line creation

      // Set line properties
      ObjectSetInteger(0, lineName, OBJPROP_COLOR, lineColor);
      ObjectSetInteger(0, lineName, OBJPROP_STYLE, lineStyle);
      ObjectSetInteger(0, lineName, OBJPROP_WIDTH, lineWidth);
      ObjectSetDouble(0, lineName, OBJPROP_PRICE, normalizedPrice);
     }
   else
     {
      int errorcode = GetLastError();
      ////Print("Failed to create line: ", lineName, " Error: ", errorcode);
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int FindIndices(double value, double &arr[], int &indexlow, int &indexhigh)
  {
   int size = ArraySize(arr);

// Check if the array has at least two elements
   if(size < 2)
     {
      Print("Array must have at least two elements.");
      //      return -1; // Return -1 to indicate an error
     }

// Iterate through the array to find the indices
   for(int i = 0; i < size - 1; i++)
     {
      if((value > arr[i] && value < arr[i+1]) || (value < arr[i] && value > arr[i+1]))
        {
         indexlow = i;
         indexhigh = i + 1;
         return 0; // Return 0 to indicate success
        }
     }

// If no such indices are found
   Print("No indices found where the value is between two consecutive elements.");
   return -1; // Return -1 to indicate failure
  }




//+------------------------------------------------------------------+
void CalculateVolumeDistribution(int Days, double levelStep, double &volumeArray[], double &priceLevelArray[])
  {
// Determine the number of bars in two full days
   int barsInFullDay = 1440; // 1440 minutes in a day
   int barsInDays = Days * barsInFullDay;

// Calculate the number of bars that have elapsed today
   datetime currentTime = TimeCurrent();
   datetime startOfDay = currentTime - (currentTime % 86400); // Start of the current day
   int barsElapsedToday = (int)((currentTime - startOfDay) / 60) ;    // Convert seconds to minutes

// Total lookback bars
   int lookbackBars = barsInDays + barsElapsedToday;

// Initialize variables to store the lowest low and highest high
   double lowestLow = 0;
   double highestHigh = 0;

// Arrays to store the data
   double lowArray[];
   double highArray[];
   long volumeArrayRaw[];

// Copy the data for the specified number of bars
   if(CopyLow(_Symbol, PERIOD_M1, 0, lookbackBars, lowArray) <= 0 ||
      CopyHigh(_Symbol, PERIOD_M1, 0, lookbackBars, highArray) <= 0 ||
      CopyTickVolume(_Symbol, PERIOD_M1, 0, lookbackBars, volumeArrayRaw) <= 0)
     {
      Print("Error copying data");
      return;
     }

// Loop through the lookback period to find the lowest low and highest high
   for(int i = 0; i < lookbackBars; i++)
     {
      double low = lowArray[i];
      double high = highArray[i];

      if((low != 0 && low < lowestLow) || lowestLow == 0)
         lowestLow = low;
      if(high > highestHigh)
         highestHigh = high;
     }
   Print("Lowest Level: ", lowestLow);
   Print("Highest Level: ", highestHigh);

// Calculate the number of levels
   int numberOfLevels = int((highestHigh - lowestLow) / levelStep) + 1;

// Resize the arrays to hold the data
   ArrayResize(volumeArray, numberOfLevels);
   ArrayResize(priceLevelArray, numberOfLevels);

// Initialize arrays
   for(int i = 0; i < numberOfLevels; i++)
     {
      volumeArray[i] = 0;
      priceLevelArray[i] = lowestLow + i * levelStep;
     }

// Aggregate volume for each level
   for(int i = 0; i < lookbackBars; i++)
     {
      double low = lowArray[i];
      double high = highArray[i];
      double volume = (double)volumeArrayRaw[i];

      // Determine which levels the current bar's range covers
      int startLevel = int((low - lowestLow) / levelStep);
      int endLevel = int((high - lowestLow) / levelStep);

      // Distribute volume across the levels covered by the bar
      for(int level = startLevel; level <= endLevel; level++)
        {
         if(level >= 0 && level < numberOfLevels)
           {
            volumeArray[level] += volume;
            //Print("Level: ", level, " Volume: ", volumeArray[level]);
           }
        }
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double  meanEntryPrice(string type)
  {

   double quantity = 0;
   double volume = 0;
   double entry = 0;


   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      //////////////////////////////////

      if(type == "Buy" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();
        }
      if(type == "Sell" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume =  volume + PosInfo.Volume();
        }
      if(type == "Total" && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();

        }


      if(type == "BuysAbove" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PosInfo.PriceOpen() > PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();
        }

      if(type == "BuysBelow" && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PosInfo.PriceOpen() < PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();
        }


      /////////////////////////////



      if(type == "SellsAbove" && PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() > PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)

        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();
        }
      if(type == "SellsBelow" && PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < PosInfo.PriceCurrent() && PositionGetString(POSITION_SYMBOL) == _Symbol)

        {
         quantity = quantity + PosInfo.Volume()*PosInfo.PriceOpen();
         volume = volume + PosInfo.Volume();
        }
     }

   entry = quantity / volume;
   return entry;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int ArrayPeaks(const double &array[], int &peaks[], double min_distance)
  {

   int LevelsToCheck = Grid;

   int array_size = ArraySize(array);
   if(array_size < LevelsToCheck)
      return 0; // Return 0 if the array is too small to have peaks

   int peak_count = 0;
   ArrayResize(peaks, array_size); // Resize peaks array to the maximum possible size initially

// Iterate through the array to find peaks
   for(int i = (int)(LevelsToCheck/2); i < array_size - (int)(LevelsToCheck/2); i++) // Start from level index and end at array_size - level index
     {
      bool is_peak = true;
      // Check if the current element is greater than the elements in the range of indices around it
      for(int j = i - (int)(LevelsToCheck/2); j <= i + (int)(LevelsToCheck/2); j++)
        {
         if(j != i && array[i] <= array[j])
           {
            is_peak = false;
            break;
           }

        }

      if(is_peak)
        {
         bool is_far_enough = true;
         for(int j = 0; j < peak_count; j++)
           {
            if(MathAbs(i - peaks[j]) < min_distance)
              {
               is_far_enough = false;
               break;
              }
           }
         if(is_far_enough)
           {
            peaks[peak_count] = i;
            peak_count++;
           }
        }
     }

   ArrayResize(peaks, peak_count); // Resize peaks array to the actual number of peaks found
   return peak_count; // Return the number of peaks found
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateValueArea(const double &priceLevels[], const double &volumes[], double &valAreaHigh, double &valAreaLow, double percentage = 70.0)
  {
   int size = ArraySize(volumes);
   if(size <= 0 || size != ArraySize(priceLevels))
     {
      //Print("Array Issue: Price Levels and Volumes don't match or are empty.");
      return;
     }

// Calculate total volume
   double totalVolume = 0.0;
   for(int i = 0; i < size; i++)
     {
      totalVolume += volumes[i];
     }

// Target volume for the value area
   double targetVolume = totalVolume * (percentage / 100.0);

// Find the POC
   int pocIndex = 0;
   double maxVolume = volumes[0];
   for(int i = 1; i < size; i++)
     {
      if(volumes[i] > maxVolume)
        {
         maxVolume = volumes[i];
         pocIndex = i;
        }
     }

// Initialize the value area with the POC
   valAreaLow = priceLevels[pocIndex];
   valAreaHigh = priceLevels[pocIndex];
   double cumulativeVolume = maxVolume;

// Expand the value area around the POC
   int leftIndex = pocIndex - 1;
   int rightIndex = pocIndex + 1;

   while(cumulativeVolume < targetVolume)
     {
      // Consider both directions and choose the one with larger volume
      if(leftIndex >= 0 && (rightIndex >= size || volumes[leftIndex] >= volumes[rightIndex]))
        {
         cumulativeVolume += volumes[leftIndex];
         valAreaLow = priceLevels[leftIndex];
         leftIndex--;
        }
      else
         if(rightIndex < size)
           {
            cumulativeVolume += volumes[rightIndex];
            valAreaHigh = priceLevels[rightIndex];
            rightIndex++;
           }
         else
           {
            // No more price levels to consider
            break;
           }
     }
  }


////////////////CLOSING FUNCTIONS////////////////////////////////////

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAllPositions()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i))  // select a position
        {
         trade.PositionClose(PosInfo.Ticket());
        }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CancelLimits(string comment)
  {

   for(int i = OrdersTotal()-1; i>= 0; i--)
      if(OrdInfo.SelectByIndex(i) && PosInfo.Comment() == comment)
        {
         trade.OrderDelete(OrdInfo.Ticket());
        }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseByWinning()
  {

   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY)
           {
            double thebuy = PosInfo.PriceOpen();
            int theBuyTicket = PosInfo.Ticket();

            for(int i = PositionsTotal() - 1; i >= 0; i--)
               if(PosInfo.SelectByIndex(i))
                 {
                  if(PosInfo.PositionType() == POSITION_TYPE_SELL)
                    {
                     double thesell = PosInfo.PriceOpen();
                     int theSellTicket = PosInfo.Ticket();

                     if(thesell - thebuy > 0)
                       {
                        trade.PositionCloseBy(theBuyTicket,theSellTicket);
                       }
                    }
                 }
           }
        }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseByLosing()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         double thebuy = PosInfo.PriceOpen();
         int theBuyTicket = PosInfo.Ticket();

         for(int i = PositionsTotal() - 1; i >= 0; i--)
            if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
              {
               double thesell = PosInfo.PriceOpen();
               int theSellTicket = PosInfo.Ticket();

               if(thesell - thebuy < -Grid*_Point)
                 {
                  trade.PositionCloseBy(theBuyTicket,theSellTicket);
                 }

              }
        }

  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseByWin()
  {
   int profitTicket;
   double profit;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY)
           {
            if(PosInfo.Profit() > profit)
              {
               profit = PosInfo.Profit();
              }
            double thebuy = PosInfo.PriceOpen();
            int theBuyTicket = PosInfo.Ticket();

            for(int i = PositionsTotal() - 1; i >= 0; i--)
               if(PosInfo.SelectByIndex(i))
                 {
                  if(PosInfo.PositionType() == POSITION_TYPE_SELL)
                    {
                     double thesell = PosInfo.PriceOpen();
                     int theSellTicket = PosInfo.Ticket();

                     if(thesell - thebuy > 0)
                       {
                        trade.PositionCloseBy(theBuyTicket,theSellTicket);
                       }
                    }
                 }
           }
        }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseByLoss()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         double thebuy = PosInfo.PriceOpen();
         int theBuyTicket = PosInfo.Ticket();

         for(int i = PositionsTotal() - 1; i >= 0; i--)
            if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
              {
               double thesell = PosInfo.PriceOpen();
               int theSellTicket = PosInfo.Ticket();

               if(thesell - thebuy < -Grid*_Point)
                 {
                  trade.PositionCloseBy(theBuyTicket,theSellTicket);
                 }

              }
        }

  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseWinners()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.Profit() > 0)
           {
            int Ticket = PosInfo.Ticket();

            trade.PositionClose(Ticket);
           }
        }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseLosers()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.Profit() < 0)
           {
            int Ticket = PosInfo.Ticket();

            trade.PositionClose(Ticket);
           }
        }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double VolumeTotal(string positionType)
  {
   double totalVolume = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i) && positionType == "Buy" && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         totalVolume += PosInfo.Volume();
        }
     }
//Print("BV: " + positionType + ": "+ totalVolume);
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(PosInfo.SelectByIndex(i) && positionType == "Sell" && PosInfo.PositionType() == POSITION_TYPE_SELL)
        {
         totalVolume += PosInfo.Volume();
        }
     }
//Print("SV: " + positionType + ": " + totalVolume);
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(PosInfo.SelectByIndex(i) && positionType == "Total")
        {
         totalVolume += PosInfo.Volume();
        }
     }
//Print("TV: " + positionType + ": " + totalVolume);
   return totalVolume;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseBuyPortion(double portionToClose)
  {
   double totalVolume= 0;
   double Profit = 0;
   int ProfitTicket;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY)// && PosInfo.Profit() > Profit)
           {
            Profit = PosInfo.Profit();
            ProfitTicket = PosInfo.Ticket();
            totalVolume += PosInfo.Volume();
           }
        }
     }
//Print("BUYVOLUME: " + totalVolume);
   double openLots = totalVolume;
   double lotsToClose = NormalizeDouble(portionToClose*openLots,2);
   double closedLots = 0;

   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
        {
         while(closedLots < lotsToClose)
           {
            if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
              {
               ProfitTicket = PosInfo.Ticket();
               if(lotsToClose >= PosInfo.Volume())
                 {
                  trade.PositionClose(ProfitTicket);
                  closedLots += PosInfo.Volume();
                  //Print("Closed Buy: " + closedLots);
                  //Print("To Close Buy: " + lotsToClose);
                  continue;
                 }
               else
                 {
                  trade.PositionClosePartial(ProfitTicket,lotsToClose - closedLots);
                  break;
                 }
              }
            break;
           }
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseSellPortion(double portionToClose)
  {
   double totalVolume= 0;
   double Profit = 0;
   int ProfitTicket;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_SELL)// && PosInfo.Profit() > Profit)
           {
            Profit = PosInfo.Profit();
            ProfitTicket = PosInfo.Ticket();
            totalVolume+= PosInfo.Volume();

           }
        }
     }
//Print("SELLVOLUME: " + totalVolume);
   double openLots = totalVolume;
   double lotsToClose = NormalizeDouble(portionToClose*openLots,2);
   double closedLots = 0;

   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      while(closedLots < lotsToClose)
        {
         if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_SELL)
           {
            ProfitTicket = PosInfo.Ticket();
            if(lotsToClose >= PosInfo.Volume())
              {
               trade.PositionClose(ProfitTicket);
               closedLots += PosInfo.Volume();
               //Print("Closed Sell: " + closedLots);
               //Print("To Close Sell: " + lotsToClose);
               continue;
              }
            else
              {
               trade.PositionClosePartial(ProfitTicket,lotsToClose - closedLots);
               break;
              }
           }
         break;
        }
     }

  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseBuyLoss()
  {

   Print("To close buy above mean");
   int ProfitTicket;
   double meanEntry = meanEntryPrice("Buy");
   for(int i = 0; i <=  PositionsTotal()- 1; i++) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         while(meanEntry < bid && PosInfo.Volume() < 1)
           {
            meanEntry = meanEntryPrice("Buy");
            ProfitTicket = PosInfo.Ticket();
            trade.PositionClose(ProfitTicket);
            Print("Closed Buy above mean");

           }
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseSellLoss()
  {

   Print("To close sell above mean");
   int ProfitTicket;
   double meanEntry = meanEntryPriceSell();
   for(int i = 0; i <=  PositionsTotal()- 1; i++) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_SELL)
        {
         while(meanEntry > ask && PosInfo.Volume() < 1)
           {
            meanEntry = meanEntryPrice("Buy");
            ProfitTicket = PosInfo.Ticket();
            trade.PositionClose(ProfitTicket);
            Print("Closed Sell above mean");

           }
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double HighestBuy()
  {
   double Price = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() > Price)
           {
            Price = PosInfo.PriceOpen();
           }
        }
     }
   return Price;
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double HighestSell()
  {
   double Price = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() > Price)
           {
            Price = PosInfo.PriceOpen();
           }
        }
     }
   return Price;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LowestBuy()
  {
   double Price = 2;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() < Price)
           {
            Price = PosInfo.PriceOpen();
           }
        }
     }

   return Price;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LowestSell()
  {
   double Price = 2;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < Price)
           {
            Price = PosInfo.PriceOpen();
           }
        }
     }
   return Price;
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void MAStopLoss()
  {
   int ProfitTicket;
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i))
        {
         if(PosInfo.PositionType() == POSITION_TYPE_BUY && PosInfo.PriceOpen() > MAHigh[0] && PosInfo.PriceCurrent() < MALow[0])
           {
            ProfitTicket = PosInfo.Ticket();
            trade.PositionClose(ProfitTicket);
           }

         if(PosInfo.PositionType() == POSITION_TYPE_SELL && PosInfo.PriceOpen() < MALow[0]&& PosInfo.PriceCurrent() > MAHigh[0])
           {
            ProfitTicket = PosInfo.Ticket();
            trade.PositionClose(ProfitTicket);
           }
        }
     }
  }



///////////////////POSITIONS CHECK/////////////////////////

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool OtherBuyPosition(string comment)
  {
   bool other = false;

   for(int i = PositionsTotal(); i >=0; i--)
     {
      ulong ticket = PositionGetTicket(i);

      if(PosInfo.SelectByTicket(ticket))
        {
         double currentPrice = PosInfo.PriceCurrent();
         double openPrice = PosInfo.PriceOpen();

         if(MathAbs(currentPrice-openPrice) < Grid_step_buy*_Point && PosInfo.PositionType() == POSITION_TYPE_BUY && (comment == PosInfo.Comment() || comment == NULL))
           {
            Print("Ticket#: " + ticket);
            other = true;
            break;
           }
         else
           {
            other = false;
           }
        }
     }
   Print("otherbuyposition: " + other);
   return other;
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool OtherSellPosition(string comment)
  {

   bool other = false;

   for(int i = PositionsTotal(); i >=0; i--)
     {
      ulong ticket = PositionGetTicket(i);

      if(PosInfo.SelectByTicket(ticket))
        {
         double currentPrice = PosInfo.PriceCurrent();
         double openPrice = PosInfo.PriceOpen();

         if(MathAbs(currentPrice-openPrice) < Grid_step_sell*_Point && PosInfo.PositionType() == POSITION_TYPE_SELL && (comment == PosInfo.Comment() || comment == NULL))
           {
            other = true;
            break;
           }
         else
           {
            other = false;
           }
        }
     }
   Print("othersellposition: " + other);
   return other;
  }




//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseBuys()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         double thebuy = PosInfo.PriceOpen();
         int theBuyTicket = PosInfo.Ticket();


         trade.PositionClose(theBuyTicket);

        }

  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseSells()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--) // loop all Open Positions
      if(PosInfo.SelectByIndex(i) &&PosInfo.PositionType() == POSITION_TYPE_SELL)
        {
         double thesell = PosInfo.PriceOpen();
         int theSellTicket = PosInfo.Ticket();


         trade.PositionClose(theSellTicket);


        }


  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseBuy()
  {
   double Profit;
   int theBuyTicket = PosInfo.Ticket();
   for(int i = PositionsTotal() - 1; i >= 0; i--)  // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_BUY)
        {
         if(Profit>PosInfo.Profit())
           {
            Profit = PosInfo.Profit();
            theBuyTicket = PosInfo.Ticket();
           }
        }
     }
   trade.PositionClose(theBuyTicket);
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseSell()
  {
   double Profit;
   int theSellTicket = PosInfo.Ticket();
   for(int i = PositionsTotal() - 1; i >= 0; i--)  // loop all Open Positions
     {
      if(PosInfo.SelectByIndex(i) && PosInfo.PositionType() == POSITION_TYPE_SELL)
        {
         if(Profit>PosInfo.Profit())
           {
            Profit = PosInfo.Profit();
            theSellTicket = PosInfo.Ticket();
           }
        }
     }
   trade.PositionClose(theSellTicket);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trailing()
  {
//      if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
//      {

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      //            string symbol = PositionGetSymbol(i);
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);
      if(trade_type == 0)// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
        {

         if(bid > PositionGetDouble(POSITION_PRICE_OPEN) + NormalizeDouble(_Point * Grid,_Digits))
           {
            trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
           }
        }

      if(trade_type == 1)// && (PositionGetString(POSITION_COMMENT) == "SellLimit"|| PositionGetString(POSITION_COMMENT) == "SellGrid"))
        {

         if(ask < PositionGetDouble(POSITION_PRICE_OPEN) - NormalizeDouble(_Point * Grid,_Digits))
           {
            trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
           }
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void TPmodify()
  {
//      if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
//      {

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);
      if(trade_type == 0 && PosInfo.TakeProfit() != meanEntryPrice("Buy") + TakeProfitFactor*Grid*_Point && BuyPositionsCount() > PositionsThreshold)
        {
         trade.PositionModify(PositionTicket,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN) + TakeProfitFactor*Grid*_Point);
         //if(PosInfo.PriceCurrent() > meanEntryPrice("Buy") + Grid*_Point)
         //   CloseBuys();
        }

      if(trade_type == 1 && PosInfo.TakeProfit() != meanEntryPriceSell() - TakeProfitFactor*Grid*_Point && SellPositionsCount() > PositionsThreshold)
        {
         trade.PositionModify(PositionTicket,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN) - TakeProfitFactor*Grid*_Point);
         //if(PosInfo.PriceCurrent() < meanEntryPriceSell() - Grid*_Point)
         //   CloseSells();
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void breakEven()
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);
      if(trade_type == 0)
         if(PosInfo.PriceCurrent() - PosInfo.PriceOpen() > BiasFactor*Grid*_Point && (PosInfo.StopLoss() < PosInfo.PriceOpen() || PosInfo.StopLoss() == 0))// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
           {
            trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
           }
      if(trade_type == 1)
         if(PosInfo.PriceCurrent() - PosInfo.PriceOpen()  < BiasFactor*Grid*_Point && (PosInfo.StopLoss() > PosInfo.PriceOpen() || PosInfo.StopLoss() == 0))// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
           {
            trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
           }
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void slStepUp()
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);
      if(trade_type == 0 && PosInfo.StopLoss() > PosInfo.PriceOpen())// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
        {
         trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_SL) + Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
        }
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void slStepDown()
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);
      if(trade_type == 1 && PosInfo.StopLoss() < PosInfo.PriceOpen())// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
        {
         trade.PositionModify(PositionTicket,NormalizeDouble(PositionGetDouble(POSITION_SL) - Grid*_Point,_Digits),PositionGetDouble(POSITION_TP));
        }
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void StoplossUpdate(string comment)
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);

      if(trade_type == 0 && comment == "buy" && PositionGetDouble(POSITION_PRICE_CURRENT) - atr[1] > PositionGetDouble(POSITION_PRICE_OPEN) + Grid*_Point)// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
        {
         double newStopLoss = NormalizeDouble(((PosInfo.PriceCurrent()+PosInfo.PriceOpen())/2 - atr[1]),_Digits);
         if(PositionGetDouble(POSITION_SL) < newStopLoss)
            trade.PositionModify(PositionTicket,newStopLoss,PositionGetDouble(POSITION_TP));
        }

      if(trade_type == 1 && comment == "sell" && PositionGetDouble(POSITION_PRICE_CURRENT) + atr[1] < PositionGetDouble(POSITION_PRICE_OPEN) - Grid*_Point)// && (PositionGetString(POSITION_COMMENT) == "BuyLimit" || PositionGetString(POSITION_COMMENT) == "BuyGrid"))
        {
         double newStopLoss = NormalizeDouble(((PosInfo.PriceCurrent()+PosInfo.PriceOpen())/2 + atr[1]),_Digits);
         if(PositionGetDouble(POSITION_SL) > newStopLoss)
            trade.PositionModify(PositionTicket,newStopLoss,PositionGetDouble(POSITION_TP));
        }

     }
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string crossOver(double &Array1[], double &Array2[])
  {
   string crossOver;
   if(Array1[1] > Array2[1] && Array1[2] < Array2[2])
     {
      crossOver = "up";
     }
   if(Array1[1] < Array2[1] && Array1[2] > Array2[2])
     {
      crossOver = "down";
     }
   else
     {
      crossOver = NULL;
     }

   return (crossOver);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int BuyPositionsCount()
  {
   int Buys = 0;
   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         Buys = Buys+1;
        }
     }
   return Buys;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int SellPositionsCount()
  {
   int Sells = 0;
   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         Sells = Sells+1;
        }
     }
   return Sells;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SLmodify()
  {
//      if(PositionGetInteger(POSITION_MAGIC) == 444444)//adding magic number, if you want you can delete this if you don't want to use magic number
//      {

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong PositionTicket = PositionGetTicket(i);
      long trade_type = PositionGetInteger(POSITION_TYPE);

      if(trade_type == 0
         && PosInfo.PriceCurrent() > meanEntryPrice("Buy") + (0.5*Grid*_Point)
         && (PositionGetDouble(POSITION_SL) < PosInfo.PriceCurrent() - ((LowestBuy() + 0.5*Grid*_Point)-meanEntryPrice("Buy")) || PositionGetDouble(POSITION_SL) == 0))
        {
         trade.PositionModify(PositionTicket,PosInfo.PriceCurrent() - ((LowestBuy() + 0.5*Grid*_Point)-meanEntryPrice("Buy")),PositionGetDouble(POSITION_TP));
         Print("Lowest buy: " + LowestBuy());
        }

      if(trade_type == 1
         && PosInfo.PriceCurrent() < meanEntryPriceSell() - (0.5*Grid*_Point)
         && (PositionGetDouble(POSITION_SL) > PosInfo.PriceCurrent() - ((HighestSell() - 0.5*Grid*_Point)-meanEntryPriceSell()) || PositionGetDouble(POSITION_SL) == 0))
        {
         trade.PositionModify(PositionTicket,PosInfo.PriceCurrent() - ((HighestSell() - 0.5*Grid*_Point)-meanEntryPriceSell()),PositionGetDouble(POSITION_TP));
         Print("highest sell: " + HighestSell());
        }
     }

  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double  meanEntryPriceBuy()
  {

   double price = 0;
   double volume = 0;
   double entry;
   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         price = price + PosInfo.Volume()*PosInfo.PriceOpen();
        }
     }

   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         volume = volume + PosInfo.Volume();
        }
     }

   entry = price / volume;
   return entry;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double  meanEntryPriceSell()
  {

   double price = 0;
   double volume = 0;
   double entry;
   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         price = price + PosInfo.Volume()*PosInfo.PriceOpen();
        }
     }

   for(int i = PositionsTotal()-1; i>=0; i--)
     {
      PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetString(POSITION_SYMBOL) == _Symbol)
        {
         volume = volume + PosInfo.Volume();
        }
     }

   entry = price / volume;
   return entry;
  }
//+------------------------------------------------------------------+