Mars200VCE/JetVirgoPM/PMs/Routines/Process_FA.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.Common;
using Aitex.Core.RT.Event;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.FAServices;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.SubstrateTrackings;

namespace JetVirgoPM.PMs.Routines
{
    public interface IRecipeFACallback
    {
        void RecipeStart(string module, string recipeName);
        void RecipeComplete(string module, string recipeName);

        void RecipeStepStart(string module, string recipeName, int stepNumber);
        void RecipeStepEnd(string module, string recipeName, int stepNumber);

        void RecipeFailed(string module, string recipeName);

    }


    public class RecipeFACallback : IRecipeFACallback
    {
        //private const string RecipeStartEvent = "RecipeStart";
        //private const string RecipeCompleteEvent = "RecipeComplete";
        //private const string RecipeStepStartEvent = "RecipeStepStart";
        //private const string RecipeStepEndEvent = "RecipeStepEnd";
        //private const string RecipeFailedEvent = "RecipeFailed";

        private const string PMARecipeStartEvent = "PMARecipeStart";
        private const string PMARecipeCompleteEvent = "PMARecipeComplete";
        private const string PMARecipeStepStartEvent = "PMARecipeStepStart";
        private const string PMARecipeStepEndEvent = "PMARecipeStepEnd";
        private const string PMARecipeFailedEvent = "PMARecipeFailed";

        private const string PMBRecipeStartEvent = "PMBRecipeStart";
        private const string PMBRecipeCompleteEvent = "PMBRecipeComplete";
        private const string PMBRecipeStepStartEvent = "PMBRecipeStepStart";
        private const string PMBRecipeStepEndEvent = "PMBRecipeStepEnd";
        private const string PMBRecipeFailedEvent = "PMBRecipeFailed";

        private const string PMCRecipeStartEvent = "PMCRecipeStart";
        private const string PMCRecipeCompleteEvent = "PMCRecipeComplete";
        private const string PMCRecipeStepStartEvent = "PMCRecipeStepStart";
        private const string PMCRecipeStepEndEvent = "PMCRecipeStepEnd";
        private const string PMCRecipeFailedEvent = "PMCRecipeFailed";

        private const string PMDRecipeStartEvent = "PMDRecipeStart";
        private const string PMDRecipeCompleteEvent = "PMDRecipeComplete";
        private const string PMDRecipeStepStartEvent = "PMDRecipeStepStart";
        private const string PMDRecipeStepEndEvent = "PMDRecipeStepEnd";
        private const string PMDRecipeFailedEvent = "PMDRecipeFailed";

        //private const string PM1RecipeStart = "PM1RecipeStart";
        //private const string PM1RecipeComplete = "PM1RecipeComplete";
        //private const string PM1RecipeStepStart = "PM1RecipeStepStart";
        //private const string PM1RecipeStepEnd = "PM1RecipeStepEnd";
        //private const string PM1RecipeFailed = "PM1RecipeFailed";

        //private const string PM2RecipeStart = "PM2RecipeStart";
        //private const string PM2RecipeComplete = "PM2RecipeComplete";
        //private const string PM2RecipeStepStart = "PM2RecipeStepStart";
        //private const string PM2RecipeStepEnd = "PM2RecipeStepEnd";
        //private const string PM2RecipeFailed = "PM2RecipeFailed";

        //private Dictionary<ModuleName, string> PMRecipeStart = new Dictionary<ModuleName, string>()
        //{
        //    {ModuleName.PMA, PM1RecipeStart},
        //    {ModuleName.PMB, PM2RecipeStart},
        //};

        //private Dictionary<ModuleName, string> PMRecipeComplete = new Dictionary<ModuleName, string>()
        //{
        //    {ModuleName.PMA, PM1RecipeComplete},
        //    {ModuleName.PMB, PM2RecipeComplete},
        //};
        //private Dictionary<ModuleName, string> PMRecipeStepStart = new Dictionary<ModuleName, string>()
        //{
        //    {ModuleName.PMA, PM1RecipeStepStart},
        //    {ModuleName.PMB, PM2RecipeStepStart},
        //};
        //private Dictionary<ModuleName, string> PMRecipeStepEnd = new Dictionary<ModuleName, string>()
        //{
        //    {ModuleName.PMA, PM1RecipeStepEnd},
        //    {ModuleName.PMB, PM2RecipeStepEnd},
        //};
        //private Dictionary<ModuleName, string> PMRecipeFailed = new Dictionary<ModuleName, string>()
        //{
        //    {ModuleName.PMA, PM1RecipeFailed},
        //    {ModuleName.PMB, PM2RecipeFailed},
        //};

        private Dictionary<int, string> PortId = new Dictionary<int, string>()
        {
            {(int)ModuleName.VCEA, "1"},
            {(int)ModuleName.VCEB, "3"},
            {(int)ModuleName.CassAL, "1"},
            {(int)ModuleName.CassAR, "2"},
            {(int)ModuleName.CassBL, "3"},
            {(int)ModuleName.CassBR, "4"},
        };

        private const int OneValue = 1;
        private const int TwoValue = 2;

        public RecipeFACallback()
        {
            //EV.Subscribe(new EventItem("Event", RecipeStartEvent, RecipeStartEvent));
            //EV.Subscribe(new EventItem("Event", RecipeCompleteEvent, RecipeCompleteEvent));
            //EV.Subscribe(new EventItem("Event", RecipeStepStartEvent, RecipeStepStartEvent));
            //EV.Subscribe(new EventItem("Event", RecipeStepEndEvent, RecipeStepEndEvent));
            //EV.Subscribe(new EventItem("Event", RecipeFailedEvent, RecipeFailedEvent));

            EV.Subscribe(new EventItem("Event", PMARecipeStartEvent, PMARecipeStartEvent));
            EV.Subscribe(new EventItem("Event", PMARecipeCompleteEvent, PMARecipeCompleteEvent));
            EV.Subscribe(new EventItem("Event", PMARecipeStepStartEvent, PMARecipeStepStartEvent));
            EV.Subscribe(new EventItem("Event", PMARecipeStepEndEvent, PMARecipeStepEndEvent));
            EV.Subscribe(new EventItem("Event", PMARecipeFailedEvent, PMARecipeFailedEvent));

            EV.Subscribe(new EventItem("Event", PMBRecipeStartEvent, PMBRecipeStartEvent));
            EV.Subscribe(new EventItem("Event", PMBRecipeCompleteEvent, PMBRecipeCompleteEvent));
            EV.Subscribe(new EventItem("Event", PMBRecipeStepStartEvent, PMBRecipeStepStartEvent));
            EV.Subscribe(new EventItem("Event", PMBRecipeStepEndEvent, PMBRecipeStepEndEvent));
            EV.Subscribe(new EventItem("Event", PMBRecipeFailedEvent, PMBRecipeFailedEvent));

            EV.Subscribe(new EventItem("Event", PMCRecipeStartEvent, PMCRecipeStartEvent));
            EV.Subscribe(new EventItem("Event", PMCRecipeCompleteEvent, PMCRecipeCompleteEvent));
            EV.Subscribe(new EventItem("Event", PMCRecipeStepStartEvent, PMCRecipeStepStartEvent));
            EV.Subscribe(new EventItem("Event", PMCRecipeStepEndEvent, PMCRecipeStepEndEvent));
            EV.Subscribe(new EventItem("Event", PMCRecipeFailedEvent, PMCRecipeFailedEvent));

            EV.Subscribe(new EventItem("Event", PMDRecipeStartEvent, PMDRecipeStartEvent));
            EV.Subscribe(new EventItem("Event", PMDRecipeCompleteEvent, PMDRecipeCompleteEvent));
            EV.Subscribe(new EventItem("Event", PMDRecipeStepStartEvent, PMDRecipeStepStartEvent));
            EV.Subscribe(new EventItem("Event", PMDRecipeStepEndEvent, PMDRecipeStepEndEvent));
            EV.Subscribe(new EventItem("Event", PMDRecipeFailedEvent, PMDRecipeFailedEvent));

        }

        public void RecipeComplete(string module, string recipeName)
        {
            if (!ModuleHelper.IsPm(module))
                return;

            WaferInfo wafer0 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);
            WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 1);
           
            if (!wafer0.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeComplete(PMARecipeCompleteEvent, wafer0, recipeName, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeComplete(PMARecipeCompleteEvent,wafer1 , recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeComplete(PMBRecipeCompleteEvent,wafer0 , recipeName, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeComplete(PMBRecipeCompleteEvent, wafer1, recipeName, module, TwoValue);
            }
            if (!wafer0.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeComplete(PMCRecipeCompleteEvent, wafer0, recipeName, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeComplete(PMCRecipeCompleteEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeComplete(PMDRecipeStepEndEvent, wafer0, recipeName, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeComplete(PMDRecipeStepEndEvent, wafer1, recipeName, module, TwoValue);
            }
        }
        /// <summary>
        /// 上报Recipe完成事件
        /// </summary>
        /// <param name="eventName"></param>
        /// <param name="waferInfo"></param>
        /// <param name="recipeName"></param>
        /// <param name="module"></param>
        /// <param name="pmValue"></param>
        private void NotifyRecipeComplete(string eventName,WaferInfo waferInfo,string recipeName,string module,int oneTwoValue)
        {
            if (PortId.ContainsKey(waferInfo.OriginStation))
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.PortID, PortId[waferInfo.OriginStation]},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
            else
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
        }

        private string GetEAPName(string module, int slot)
        {
            var key = $"{module}{slot}";
            var map = Aitex.Core.RT.RecipeCenter.RecipeFileManager.Instance.GetPMToEapConvert();
            if (map != null && map.ContainsKey(key))
            {
                return map[key];
            }
            return module;
        }

        public void RecipeFailed(string module, string recipeName)
        {
            if (!ModuleHelper.IsPm(module))
                return;

            WaferInfo wafer0 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);
            WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 1);

            if (!wafer0.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeFailedEvent(PMARecipeFailedEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeFailedEvent(PMARecipeFailedEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeFailedEvent(PMBRecipeFailedEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeFailedEvent(PMBRecipeFailedEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeFailedEvent(PMCRecipeFailedEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeFailedEvent(PMCRecipeFailedEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeFailedEvent(PMARecipeFailedEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeFailedEvent(PMARecipeFailedEvent, wafer1, recipeName, module, TwoValue);
            }
        }

        private void NotifyRecipeFailedEvent(string eventName,WaferInfo waferInfo,string recipeName,string module,int oneTwoValue)
        {
            if (PortId.ContainsKey(waferInfo.OriginStation))
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.PortID, PortId[waferInfo.OriginStation]},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
            else
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
        }

        public void RecipeStart(string module, string recipeName)
        {
            if (!ModuleHelper.IsPm(module))
                return;

            WaferInfo wafer0 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);
            WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 1);


            if (!wafer0.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStartEvent(PMARecipeStartEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStartEvent(PMARecipeStartEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStartEvent(PMBRecipeStartEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStartEvent(PMBRecipeStartEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStartEvent(PMCRecipeStartEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStartEvent(PMCRecipeStartEvent, wafer1, recipeName, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStartEvent(PMDRecipeStartEvent, wafer0, recipeName, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStartEvent(PMDRecipeStartEvent, wafer1, recipeName, module, TwoValue);
            }
        }

        private void NotifyRecipeStartEvent(string eventName,WaferInfo waferInfo,string recipeName,string module,int oneTwoValue)
        {
            if (PortId.ContainsKey(waferInfo.OriginStation))
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.PortID, PortId[waferInfo.OriginStation]},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
            else
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
        }

        public void RecipeStepEnd(string module, string recipeName, int stepNumber)
        {
            if (!ModuleHelper.IsPm(module))
                return;

            WaferInfo wafer0 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);
            WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 1);

            if (!wafer0.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStepEndEvet(PMARecipeStepEndEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStepEndEvet(PMARecipeStepEndEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStepEndEvet(PMDRecipeStepEndEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStepEndEvet(PMBRecipeStepEndEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStepEndEvet(PMCRecipeStepEndEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStepEndEvet(PMCRecipeStepEndEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStepEndEvet(PMDRecipeStepEndEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStepEndEvet(PMDRecipeStepEndEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }
        }

        private void NotifyRecipeStepEndEvet(string eventName,WaferInfo waferInfo,string recipeName,int stepNumber,string module,int oneTwoValue)
        {
            if (PortId.ContainsKey(waferInfo.OriginStation))
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.PortID, PortId[waferInfo.OriginStation]},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
            else
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
        }

        public void RecipeStepStart(string module, string recipeName, int stepNumber)
        {
            if (!ModuleHelper.IsPm(module))
                return;

            WaferInfo wafer0 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);
            WaferInfo wafer1 = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 1);

            if (!wafer0.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStepStartEvent(PMARecipeStepStartEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                NotifyRecipeStepStartEvent(PMARecipeStepStartEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStepStartEvent(PMBRecipeStepStartEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                NotifyRecipeStepStartEvent(PMBRecipeStepStartEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStepStartEvent(PMCRecipeStepStartEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMC.ToString())
            {
                NotifyRecipeStepStartEvent(PMCRecipeStepStartEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStepStartEvent(PMDRecipeStepStartEvent, wafer0, recipeName, stepNumber, module, OneValue);
            }
            if (!wafer1.IsEmpty && module == ModuleName.PMD.ToString())
            {
                NotifyRecipeStepStartEvent(PMDRecipeStepStartEvent, wafer1, recipeName, stepNumber, module, TwoValue);
            }
        }
        /// <summary>
        /// 上报RecipeStep开始事件
        /// </summary>
        /// <param name="eventName"></param>
        /// <param name="waferInfo"></param>
        /// <param name="recipeName"></param>
        /// <param name="stepNumber"></param>
        /// <param name="module"></param>
        /// <param name="oneTwoValue"></param>
        private void NotifyRecipeStepStartEvent(string eventName,WaferInfo waferInfo,string recipeName,int stepNumber,string module,int oneTwoValue)
        {
            if (PortId.ContainsKey(waferInfo.OriginStation))
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName, GetEAPName(module, oneTwoValue)},
                        {DataVariables.PortID, PortId[waferInfo.OriginStation]},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
            else
            {
                EV.Notify(eventName, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  waferInfo.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, oneTwoValue)},
                        {DataVariables.CarrierID,  waferInfo.OriginCarrierID},
                        {DataVariables.SlotID, (waferInfo.OriginSlot+1).ToString()}
                    });
            }
        }
    }
}