Virgo_Mask/VirgoRT/Modules/PMs/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.CommonData;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.SubstrateTrackings;
using VirgoRT.HostWrapper;

namespace VirgoRT.Modules.PMs
{
    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, List<FdcDataItem> fdc);

        void RecipeFailed(string module, string recipeName);

    }


    public class RecipeFACallback : IRecipeFACallback
    {
        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"},
        };

        public RecipeFACallback()
        {
            EV.Subscribe(new EventItem("Event", PM1RecipeStart, PM1RecipeStart));
            EV.Subscribe(new EventItem("Event", PM1RecipeComplete, PM1RecipeComplete));
            EV.Subscribe(new EventItem("Event", PM1RecipeStepStart, PM1RecipeStepStart));
            EV.Subscribe(new EventItem("Event", PM1RecipeStepEnd, PM1RecipeStepEnd));
            EV.Subscribe(new EventItem("Event", PM1RecipeFailed, PM1RecipeFailed));

            EV.Subscribe(new EventItem("Event", PM2RecipeStart, PM2RecipeStart));
            EV.Subscribe(new EventItem("Event", PM2RecipeComplete, PM2RecipeComplete));
            EV.Subscribe(new EventItem("Event", PM2RecipeStepStart, PM2RecipeStepStart));
            EV.Subscribe(new EventItem("Event", PM2RecipeStepEnd, PM2RecipeStepEnd));
            EV.Subscribe(new EventItem("Event", PM2RecipeFailed, PM2RecipeFailed));

        }

        public void RecipeComplete(string module, string recipeName)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);

            if (wafer.IsEmpty)
                return;

            ModuleName moduleName = ModuleHelper.Converter(module);

            if (PortId.ContainsKey(wafer.OriginStation))
            {
                EV.Notify(PMRecipeComplete[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID,  recipeName},
                    {DVIDName.StationName,  module},
                    {DVIDName.PortID, PortId[wafer.OriginStation]},
                    {DVIDName.SlotID, (wafer.OriginSlot+1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
            else
            {
                EV.Notify(PMRecipeComplete[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID,  recipeName},
                    {DVIDName.StationName,  module},
                    {DVIDName.SlotID, (wafer.OriginSlot+1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }

        }

        public void RecipeFailed(string module, string recipeName)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);

            if (wafer.IsEmpty)
                return;

            ModuleName moduleName = ModuleHelper.Converter(module);

            if (PortId.ContainsKey(wafer.OriginStation))
            {
                EV.Notify(PMRecipeFailed[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.PortID, PortId[wafer.OriginStation]},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
            else
            {
                EV.Notify(PMRecipeFailed[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
        }

        public void RecipeStart(string module, string recipeName)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);

            if (wafer.IsEmpty)
                return;

            ModuleName moduleName = ModuleHelper.Converter(module);

            if (PortId.ContainsKey(wafer.OriginStation))
            {
                EV.Notify(PMRecipeStart[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.PortID, PortId[wafer.OriginStation]},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
            else
            {
                EV.Notify(PMRecipeStart[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
        }

        public void RecipeStepEnd(string module, string recipeName, int stepNumber, List<FdcDataItem> fdc)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);

            if (wafer.IsEmpty)
                return;

            ModuleName moduleName = ModuleHelper.Converter(module);

            if (PortId.ContainsKey(wafer.OriginStation))
            {
                EV.Notify(PMRecipeStepEnd[moduleName], new SerializableDictionary<string, object>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.RecipeStepNumber, (stepNumber + 1).ToString()},
                    {DVIDName.PortID, PortId[wafer.OriginStation]},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.RecipeStepEndDataSummary, fdc},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
            else
            {
                EV.Notify(PMRecipeStepEnd[moduleName], new SerializableDictionary<string, object>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.RecipeStepNumber, (stepNumber + 1).ToString()},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.RecipeStepEndDataSummary, fdc},
                    {DVIDName.LotID, wafer.LotId}

                });
            }
        }

        public void RecipeStepStart(string module, string recipeName, int stepNumber)
        {
            WaferInfo wafer = WaferManager.Instance.GetWafer(ModuleHelper.Converter(module), 0);

            if (wafer.IsEmpty)
                return;

            ModuleName moduleName = ModuleHelper.Converter(module);
            if (PortId.ContainsKey(wafer.OriginStation))
            {
                EV.Notify(PMRecipeStepStart[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.RecipeStepNumber, (stepNumber + 1).ToString()},
                    {DVIDName.PortID, PortId[wafer.OriginStation]},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
            else
            {
                EV.Notify(PMRecipeStepStart[moduleName], new SerializableDictionary<string, string>()
                {
                    {DVIDName.RecipeID, recipeName},
                    {DVIDName.StationName, module},
                    {DVIDName.RecipeStepNumber, (stepNumber + 1).ToString()},
                    {DVIDName.SlotID, (wafer.OriginSlot + 1).ToString()},
                    {DVIDName.LotID, wafer.LotId}
                });
            }
        }
    }
}