Optimization would not work , backtesting is working

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.RussianStandardTime, AccessRights = AccessRights.FullAccess)]
    public class Donci3Av7 : Robot
    {
        #region Parameters
        [Parameter("Instance Name", DefaultValue = "Blue")]
        public string InstanceName { get; set; }

        [Parameter()]
        public DataSeries Source { get; set; }

        [Parameter("Time Frame 2", DefaultValue = "Daily")]
        public TimeFrame TimeFrame2 { get; set; }

        [Parameter("Time Frame 3", DefaultValue = "Hour12")]
        public TimeFrame TimeFrame3 { get; set; }

        [Parameter("SL ATR multiple", DefaultValue = 2.2)]
        public double ATRfactor { get; set; }

        [Parameter("Hi Periods", DefaultValue = 20, MinValue =15, MaxValue =40, Step =1)]
        public int HiPer { get; set; }

        [Parameter("Low Periods", DefaultValue = 10, MinValue = 5, MaxValue =30, Step =1)]
        public int LowPer { get; set; }

        [Parameter("Quantity (Lots)", DefaultValue = 0.1, MinValue = 0.01, Step = 0.01)]
        public double Quantity { get; set; }

        [Parameter("Include Trading Hours", DefaultValue = false)]
        public bool IncludeTradinHours { get; set; }

        [Parameter("Start Hour", DefaultValue = 0.0, MinValue = 0.0, MaxValue = 24.0, Step = 0.5)]
        public double StartTime { get; set; }

        [Parameter("Stop Hour", DefaultValue = 24.0, MinValue = 0.0, MaxValue = 24.0, Step = 0.5)]
        public double StopTime { get; set; }

        [Parameter("Include Break-Even", DefaultValue = true)]
        public bool IncludeBreakEven { get; set; }

        [Parameter("Break-Even Trigger (SL)", DefaultValue = 1, MinValue = 0.4, MaxValue = 4.0)]
        public double Trigger { get; set; }

        [Parameter("Break-Even Extra (pips)", DefaultValue = 1.0, MinValue = 0.0)]
        public double ExtraPips { get; set; }

        [Parameter("Include Trailing Stop", DefaultValue = true)]
        public bool IncludeTrailingStop { get; set; }

        [Parameter("Trailing Stop Trigger (SL)", DefaultValue = 1.5, MinValue = 0.3, Step = 0.1)]
        public double TrailingStopTrigger { get; set; }

        [Parameter("Trailing Stop Step (SL)", DefaultValue = 1.2, MinValue = 0.1, Step = 0.1)]
        public double TrailingStopStep { get; set; }

        [Parameter("Max Spread (Pips)", DefaultValue = 2.0, MaxValue = 50.0, Step = 0.1)]
        public double MaxSpread { get; set; }



        private DateTime _startTime;
        private DateTime _stopTime;
        private double ma_Distance;
        private MarketSeries series2;
        private MarketSeries series3;
        private MovingAverage MA2;
        private MovingAverage MA3;
        private MovingAverage MA;
        private string _Blue;
        public double SL;
        private double _ATR;
        private DonchianChannel DCH;
        private DonchianChannel DCL;
        private AverageTrueRange ATR;
        private TradeType _tradetype;
        private bool BuyTradeOK;
        private bool SellTradeOK;
        #endregion

        #region OnStart

        protected override void OnStart()
        {
            // Start Time is the same day at 22:00:00 Server Time
            _startTime = Server.Time.Date.AddHours(StartTime);

            // Stop Time is the next day at 06:00:00
            _stopTime = Server.Time.Date.AddHours(StopTime);

            Print("Start Time {0},", _startTime);
            Print("Stop Time {0},", _stopTime);
            ma_Distance = 0.2;
            ma_Distance = ma_Distance * Symbol.PipSize;
            series2 = MarketData.GetSeries(TimeFrame2);
            series3 = MarketData.GetSeries(TimeFrame3);
            MA = Indicators.MovingAverage(Source, HiPer, MovingAverageType.Exponential);
            MA2 = Indicators.MovingAverage(series2.Close, HiPer, MovingAverageType.Exponential);
            MA3 = Indicators.MovingAverage(series3.Close, HiPer, MovingAverageType.Exponential);
            _Blue = "Donci 3Av7 " + "Blue" + " " + Symbol.Code;
            InstanceName = _Blue;
            ATR = Indicators.AverageTrueRange(LowPer, MovingAverageType.Exponential);
            SL = ATR.Result.LastValue * ATRfactor / Symbol.PipSize;
            DCH = Indicators.DonchianChannel(HiPer);
            DCL = Indicators.DonchianChannel(LowPer);
            _ATR = ATR.Result.LastValue;
        }

        #endregion

        #region OnTick
        protected override void OnTick()
        {
            if (IncludeTradinHours)
            {
                var currentHours = Server.Time.TimeOfDay.TotalHours;
                bool tradeTime = StartTime < StopTime ? currentHours > StartTime && currentHours < StopTime : currentHours < StopTime || currentHours > StartTime;

                if (!tradeTime)
                    return;
            }
            var position = Positions.Find(InstanceName, Symbol);
            if (position == null)
            {
                if (MA2.Result.LastValue < Symbol.Bid - ma_Distance && MA3.Result.LastValue < Symbol.Bid - ma_Distance && MA2.Result.IsRising() && MA3.Result.IsRising() && Symbol.Spread <= MaxSpread)
                {
                    BuyTradeOK = true;
                    SellTradeOK = false;
                }
                if (MA2.Result.LastValue > Symbol.Ask + ma_Distance && MA3.Result.LastValue > Symbol.Ask + ma_Distance && MA2.Result.IsFalling() && MA3.Result.IsFalling() && Symbol.Spread <= MaxSpread)
                {
                    BuyTradeOK = false;
                    SellTradeOK = true;
                }
                if ((DCH.Top.LastValue < Symbol.Bid && BuyTradeOK) || (DCH.Bottom.LastValue > Symbol.Bid && SellTradeOK))
                {
                    _tradetype = BuyTradeOK ? TradeType.Buy : TradeType.Sell;
                    Open(_tradetype);
                }
            }
            else if (position != null)
            {
                if ((position.TradeType == TradeType.Buy && DCL.Bottom.LastValue > Symbol.Bid) || (position.TradeType == TradeType.Sell && DCL.Top.LastValue < Symbol.Bid))
                {
                    ClosePosition(position);
                }
            }

            if (IncludeBreakEven == true)
                GoToBreakEven();
            if (IncludeTrailingStop == true)
                SetTrailingStop();
        }
        #endregion

        #region Open trade
        void Open(TradeType tradeType)
        {

            var volumeInUnits = Symbol.QuantityToVolume(Quantity);
            SL = ATR.Result.LastValue * ATRfactor / Symbol.PipSize;
            ExecuteMarketOrder(tradeType, Symbol, volumeInUnits, InstanceName, SL, null);
        }
        #endregion

        #region Break Even
        void GoToBreakEven()
        {
            var position = Positions.Find(InstanceName, Symbol);
            if (position != null)
            {
                var entryPrice = position.EntryPrice;
                var distance = 0.0;
                var adjEntryPrice = 0.0;

                if (position.TradeType == TradeType.Buy)
                {
                    adjEntryPrice = entryPrice + ExtraPips * Symbol.PipSize;
                    distance = Symbol.Bid - entryPrice;
                }
                else
                {
                    adjEntryPrice = entryPrice - ExtraPips * Symbol.PipSize;
                    distance = entryPrice - Symbol.Ask;
                }
                if (distance >= Trigger * SL * Symbol.PipSize)
                {
                    if (position.TradeType == TradeType.Sell && position.StopLoss > adjEntryPrice)
                        ModifyPosition(position, adjEntryPrice, null);
                    if (position.TradeType == TradeType.Buy && position.StopLoss < adjEntryPrice)
                        ModifyPosition(position, adjEntryPrice, null);
                }

            }
        }
        #endregion

        #region Trailing Stop

        private void SetTrailingStop()
        {

            var sellPositions = Positions.FindAll(InstanceName, Symbol, TradeType.Sell);

            foreach (Position position in sellPositions)
            {
                double distance = position.EntryPrice - Symbol.Ask;

                if (distance < TrailingStopTrigger * SL * Symbol.PipSize)
                    continue;

                double newStopLossPrice = Symbol.Ask + TrailingStopStep * SL * Symbol.PipSize;

                if (position.StopLoss == null || newStopLossPrice < position.StopLoss)
                {
                    ModifyPosition(position, newStopLossPrice, position.TakeProfit);
                }
            }

            var buyPositions = Positions.FindAll(InstanceName, Symbol, TradeType.Buy);

            foreach (Position position in buyPositions)
            {
                double distance = Symbol.Bid - position.EntryPrice;

                if (distance < TrailingStopTrigger * SL * Symbol.PipSize)
                    continue;

                double newStopLossPrice = Symbol.Bid - TrailingStopStep * SL * Symbol.PipSize;
                if (position.StopLoss == null || newStopLossPrice > position.StopLoss)
                {
                    ModifyPosition(position, newStopLossPrice, position.TakeProfit);
                }
            }
        }
        #endregion

    }

}

I will try to add the screens