Mars200/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.LP1, "1"},
            {(int)ModuleName.LP2, "2"},
            {(int)ModuleName.LP3, "3"},
        };

        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())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMARecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMARecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMBRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMBRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMCRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMCRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMDRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMDRecipeCompleteEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.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())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMARecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMARecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMBRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMBRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMCRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMCRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMDRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMDRecipeFailedEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.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())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMARecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMARecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMBRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMBRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMCRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMCRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMDRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMDRecipeStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.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())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMARecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMARecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMBRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMBRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMCRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMCRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMDRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMDRecipeStepEndEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.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())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMARecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMARecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMA.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMBRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMBRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,   GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer0.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer0.OriginStation))
                {
                    EV.Notify(PMCRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,   GetEAPName(module, OneValue)},
                        {DataVariables.PortID, PortId[wafer0.OriginStation]},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMCRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer0.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, OneValue)},
                        {DataVariables.CarrierID,  wafer0.OriginCarrierID},
                        {DataVariables.SlotID, (wafer0.OriginSlot+1).ToString()}
                    });
                }
            }

            if (!wafer1.IsEmpty && module == ModuleName.PMB.ToString())
            {
                if (PortId.ContainsKey(wafer1.OriginStation))
                {
                    EV.Notify(PMDRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName, GetEAPName(module, TwoValue)},
                        {DataVariables.PortID, PortId[wafer1.OriginStation]},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
                else
                {
                    EV.Notify(PMDRecipeStepStartEvent, new SerializableDictionary<string, string>()
                    {
                        {DataVariables.LotID,  wafer1.LotId},
                        {DataVariables.RecipeID,  recipeName},
                        { DataVariables.RecipeStepNumber, (stepNumber + 1).ToString() },
                        {DataVariables.StationName,  GetEAPName(module, TwoValue)},
                        {DataVariables.CarrierID,  wafer1.OriginCarrierID},
                        {DataVariables.SlotID, (wafer1.OriginSlot+1).ToString()}
                    });
                }
            }
        }
    }
}