Accessing custom indicator from cBot

How do I access the result of a custom indicator? As it stands the cBot doesn't build; it fails at "condition_UpSignal". A copy of the custom indicator is included. The indicator has been referenced. Any help is greatfully appreciated.


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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.WEuropeStandardTime, AccessRights = AccessRights.None)]
    public class CallingCustomIndic : Robot
    {
        [Parameter("Start trading (hour) 1", DefaultValue = 7)]
        public int StartHour { get; set; }

        [Parameter("Stop trading (hour) 1", DefaultValue = 23)]
        public int StopHour { get; set; }

        [Parameter("Trading hours", DefaultValue = true)]
        public bool condition_tradeHours { get; set; }

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

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

        [Parameter("Trailing Stop Trigger (pips)", DefaultValue = 0)]
        public int TrailingStopTrigger { get; set; }

        [Parameter("Trailing Stop Step (pips)", DefaultValue = 5)]
        public int TrailingStopStep { get; set; }

        [Parameter("Pip size multiplier", DefaultValue = 20)]
        public int pipSizeMultiplier { get; set; }

        [Parameter("Periods", DefaultValue = 10)]
        public int periods { get; set; }

        public string currency = "EURUSD";

        private HighToHighMA highToHigh;

        protected override void OnStart()
        {
            highToHigh = Indicators.GetIndicator<HighToHighMA>(periods);
        }

        protected override void OnTick()
        {
            ManageStop();
        }

        protected override void OnBar()
        {
            var longPosition = Positions.FindAll("", currency, TradeType.Buy);
            var position = Positions.FindAll("", currency, TradeType.Sell);

            bool condition_tradeHours = (Server.Time.Hour > StartHour) && (Server.Time.Hour < StopHour);
            bool condition_UpSignal = highToHigh.LastValue < 0.0001;

            var openPosition = Positions.Find("");
            double volume = Symbol.QuantityToVolumeInUnits(0.1);

            //to go long
            if (condition_UpSignal && condition_tradeHours)
            {
                if (!PositionOpenByType(TradeType.Buy))
                {
                    TradeResult result = ExecuteMarketOrder(TradeType.Buy, currency, volume, "", 10, null);
                }
            }
        }

        protected override void OnStop()
        {
        }

        private bool PositionOpenByType(TradeType type)
        {
            var p = Positions.FindAll("", currency, type);

            if (p.Length >= 1)
            {
                return true;
            }

            return false;
        }


        private void ManageStop()
        {
            if (PositionOpenByType(TradeType.Buy))
            {

                var position = Positions.Find("");
                var bid = Symbol.Bid;
                var ask = Symbol.Ask;
                var pipSize = Symbol.PipSize;
                var high = MarketSeries.High.Last(1);
                double distance = ask - position.EntryPrice;

                double newStopLossPrice = high - TrailingStopStep * pipSize;

                if (distance > TrailingStopTrigger * pipSize)
                {
                    if (newStopLossPrice > position.StopLoss)
                    {
                        ModifyPosition(position, newStopLossPrice, position.TakeProfit);

                        if (bid < newStopLossPrice)
                        {
                            ClosePosition(TradeType.Sell);
                        }
                    }
                }
            }
        }
        private void ClosePosition(TradeType type)
        {
            var p = Positions.Find("", currency, type);

            if (p != null)
            {
                ClosePosition(p);
            }
        }
    }
}

The custom indicator:

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

namespace cAlgo
{
    [Indicator(IsOverlay = false, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class HighToHighMA : Indicator
    {
        //[Parameter("Source")]
        //public DataSeries source { get; set; }

        [Parameter("Periods", DefaultValue = 10)]
        public int periods { get; set; }

        [Output("H to H MA")]
        public IndicatorDataSeries highToHigh { get; set; }

        private MovingAverage diffsAve;
        private IndicatorDataSeries highTradesDiff;


        protected override void Initialize()
        {
            highTradesDiff = CreateDataSeries();
            diffsAve = Indicators.MovingAverage(highTradesDiff, periods, MovingAverageType.Simple);
        }

        public override void Calculate(int index)
        {
            highTradesDiff[index] = MarketSeries.High[index - 1] - MarketSeries.High[index - 2];
            highToHigh[index] = diffsAve.Result[index];
        }
    }
}