CyberX8/CyberX8_RT/Schedulers/SchedulerManager.cs

using Aitex.Core.Common;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.Common.WaferHolder;
using CyberX8_RT.Schedulers.Aligner;
using CyberX8_RT.Schedulers.Dryer;
using CyberX8_RT.Schedulers.EfemRobot;
using CyberX8_RT.Schedulers.Loader;
using CyberX8_RT.Schedulers.Puf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CyberX8_RT.Schedulers.Prewet;
using CyberX8_RT.Schedulers.Transporter;
using CyberX8_RT.Schedulers.Rinse;
using CyberX8_RT.Schedulers.Metal;
using CyberX8_RT.Schedulers.Srd;
using CyberX8_RT.Dispatch;
using CyberX8_RT.Modules.Dryer;
using CyberX8_RT.Modules;
using Aitex.Core.RT.SCCore;

namespace CyberX8_RT.Schedulers
{
    public class SchedulerManager : Singleton<SchedulerManager>
    {
        #region 内部变量
        /// <summary>
        /// 模块类型集合字典
        /// </summary>
        private Dictionary<ModuleType, List<SchedulerModule>> _scheduleModuleTypeDic = new Dictionary<ModuleType, List<SchedulerModule>>();
        /// <summary>
        /// 模块字典
        /// </summary>
        private Dictionary<ModuleName, SchedulerModule> _scheduleModuleDic = new Dictionary<ModuleName, SchedulerModule>();
        /// <summary>
        /// 是否启用QDR时间轴
        /// </summary>
        private bool _isQdrCheckConflict = false;
        #endregion

        #region 属性
        /// <summary>
        /// 是否启用QDR时间轴
        /// </summary>
        public bool IsQdrCheckConflict { get { return _isQdrCheckConflict; } }
        #endregion

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            _isQdrCheckConflict = SC.GetValue<bool>("Scheduler.IsQdrCheckConflict");
            AddScheduleModule(ModuleType.EfemRobot, new SchedulerRobot(ModuleName.EfemRobot));
            AddScheduleModule(ModuleType.Aligner, new SchedulerAligner(ModuleName.Aligner1));
            InitializeSchedulerModules(PufItemManager.Instance.InstalledModules, ModuleType.PUF, typeof(SchedulerPuf));
            InitializeSchedulerModules(LoaderItemManager.Instance.InstalledModules, ModuleType.Loader, typeof(SchedulerLoader));
            if (ModuleHelper.IsInstalled(ModuleName.Transporter2))
            {
                InitializeSchedulerModule(ModuleName.Transporter2.ToString(), ModuleType.Transporter, typeof(SchedulerLoaderTransporter));
            }
            if(ModuleHelper.IsInstalled(ModuleName.Transporter1))
            {
                InitializeSchedulerModule(ModuleName.Transporter1.ToString(), ModuleType.Transporter, typeof(SchedulerProcessTransporter));
            }
            InitializeSchedulerModules(PrewetItemManager.Instance.InstalledModules, ModuleType.Prewet, typeof(SchedulerPrewet));
            InitializeSchedulerModules(BufferItemManager.Instance.InstalledModules, ModuleType.Buffer, typeof(SchedulerBuffer));
            InitializeSchedulerModules(RinseItemManager.Instance.InstalledModules, ModuleType.Rinse, typeof(SchedulerRinse));
            InitializeSchedulerModules(DryerItemManager.Instance.InstalledModules,ModuleType.Dryer,typeof(SchedulerDryer));
            InitializeSchedulerModules(SrdItemManager.Instance.InstalledModules,ModuleType.SRD,typeof(SchedulerSrd));
            InitializeSchedulerModules(MetalItemManager.Instance.InstalledModules, ModuleType.Metal, typeof(SchedulerMetal));
        }
        /// <summary>
        /// 重置
        /// </summary>
        public void ResetSchedulerModule()
        {
            List<ModuleName> moduleNames = _scheduleModuleDic.Keys.ToList();
            foreach(ModuleName item in moduleNames)
            {
                _scheduleModuleDic[item].ResetTask();
            }
        }
        /// <summary>
        /// 初始化调度Module集合
        /// </summary>
        private void InitializeSchedulerModules(List<string> installedModules,ModuleType moduleType,Type type)
        {
            foreach(string item in installedModules)
            {
                InitializeSchedulerModule(item, moduleType, type);
            }
        }
        /// <summary>
        /// 初始化调度Module
        /// </summary>
        /// <param name="item"></param>
        /// <param name="moduleType"></param>
        /// <param name="type"></param>
        private void InitializeSchedulerModule(string item, ModuleType moduleType, Type type)
        {
            ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), item);
            SchedulerModule schedulerModule = (SchedulerModule)System.Activator.CreateInstance(type, moduleName);
            AddScheduleModule(moduleType, schedulerModule);
        }

        /// <summary>
        /// 增加调度模块
        /// </summary>
        /// <param name="moduleType"></param>
        /// <param name="module"></param>
        private void AddScheduleModule(ModuleType moduleType, SchedulerModule module)
        {
            List<SchedulerModule> schedulers = new List<SchedulerModule>();
            if (_scheduleModuleTypeDic.ContainsKey(moduleType))
            {
                schedulers = _scheduleModuleTypeDic[moduleType];
            }
            else
            {
                _scheduleModuleTypeDic[moduleType] = schedulers;
            }
            schedulers.Add(module);
            _scheduleModuleDic[module.Module] = module;
        }
        #endregion
        /// <summary>
        /// 获取调度对象
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public SchedulerModule GetScheduler(ModuleName moduleName)
        {
            return _scheduleModuleDic.ContainsKey(moduleName)?_scheduleModuleDic[moduleName]:null;
        }
        /// <summary>
        /// 根据模块类型获取调度模块集合
        /// </summary>
        /// <param name="moduleType"></param>
        /// <returns></returns>
        public List<SchedulerModule> GetModuleTypeScheduleModules(ModuleType moduleType) 
        {
            return _scheduleModuleTypeDic.ContainsKey(moduleType) ? _scheduleModuleTypeDic[moduleType]: null;
        }
        /// <summary>
        /// 获取可用的Buffer
        /// </summary>
        /// <param name="waferSize"></param>
        /// <returns></returns>
        public WaferHolderInfo GetAvaibleBufferToLoaderWaferHolder(WaferSize waferSize, string crsType, List<string> chemistries)
        {
            bool isDryer = false;
            var result = GetAvaibleWaferHolderInfos(waferSize,crsType,chemistries,ref isDryer);
            if (isDryer)
            {
                return result.avaibleWaferHolders.Count != 0 ? result.avaibleWaferHolders[0] : null;
            }
            return GetMinTotalUseWaferHolder(result.avaibleWaferHolders);
        }
        /// <summary>
        /// 获取可用Buffer可用WaferHolder数量
        /// </summary>
        /// <param name="waferSize"></param>
        /// <returns></returns>
        public bool ExistAvaibleBufferWaferHolder(WaferSize waferSize,string crsType,List<string> chemistries)
        {
            bool isDryer = false;
            var result = GetAvaibleWaferHolderInfos(waferSize,crsType,chemistries, ref isDryer);
            return result.avaibleWaferHolders.Count>0;
        }
        /// <summary>
        /// 获取可用WaferHolder集合
        /// </summary>
        /// <param name="waferSize"></param>
        /// <returns></returns>
        private (List<WaferHolderInfo> avaibleWaferHolders, List<SchedulerModule> avaibleSchedulerModules) 
            GetAvaibleWaferHolderInfos(WaferSize waferSize, string crsType, List<string> chemistries,ref bool isDryer)
        {
            List<WaferHolderInfo> avaibleWaferHolders = new List<WaferHolderInfo>();
            List<SchedulerModule> avaibleSchedulerModules = new List<SchedulerModule>();
            List<string> dryerModules = DryerItemManager.Instance.InstalledModules;
            foreach(string item in dryerModules)
            {
                DryerEntity dryerEntity = Singleton<RouteManager>.Instance.GetModule<DryerEntity>(item);
                if (!dryerEntity.IsIdle)
                {
                    continue;
                }
                WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(item);
                if (waferHolderInfo == null)
                {
                    continue;
                }
                if (!waferHolderInfo.Enabled || waferHolderInfo.WaferSize != (int)waferSize || waferHolderInfo.CrsType != crsType 
                    || !CheckChemistry(waferHolderInfo, chemistries))
                {
                    continue;
                }
                if(!Enum.TryParse(item,out ModuleName dryerModuleName))
                {
                    continue;
                }
                if (WaferHolderTaskManager.Instance.CheckWaferHolderNotExist(waferHolderInfo))
                {
                    SchedulerModule schedulerModule = Instance.GetScheduler(dryerModuleName);
                    avaibleWaferHolders.Add(waferHolderInfo);
                    avaibleSchedulerModules.Add(schedulerModule);
                    isDryer = true;
                    return (avaibleWaferHolders, avaibleSchedulerModules);
                }
            }
            List<SchedulerModule> schedulerModules = GetModuleTypeScheduleModules(ModuleType.Buffer);

            if (schedulerModules != null)
            {
                foreach (SchedulerModule item in schedulerModules)
                {
                    WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(item.Module.ToString());
                    //WaferHolder可用,大小，以及可以移动至Loader
                    if (waferHolderInfo != null && waferHolderInfo.Enabled && waferHolderInfo.WaferSize == (int)waferSize &&waferHolderInfo.CrsType==crsType &&
                        IsWaferHolderCanGotoLoader(waferHolderInfo)&&CheckChemistry(waferHolderInfo,chemistries))
                    {
                        avaibleWaferHolders.Add(waferHolderInfo);
                        avaibleSchedulerModules.Add(item);
                    }
                }
            }
            return (avaibleWaferHolders,avaibleSchedulerModules);
        }
        /// <summary>
        /// 检验WaferHolder化学液是否合规
        /// </summary>
        /// <param name="waferHolderInfo"></param>
        /// <param name="chemistries"></param>
        /// <returns></returns>
        private bool CheckChemistry(WaferHolderInfo waferHolderInfo,List<string> chemistries)
        {
            if (chemistries.Count == 0)
            {
                return true;
            }
            if (chemistries.Count == 1)
            {
                string chemistry= chemistries[0];
                return waferHolderInfo.Chemistry == "Any" || waferHolderInfo.Chemistry.Trim() == chemistry;
            }
            else
            {
                return waferHolderInfo.Chemistry == "Any";
            }
        }
        /// <summary>
        /// 获取最少使用次数的Buffer
        /// </summary>
        /// <param name="avaibleWaferHolders"></param>
        /// <param name="modules"></param>
        /// <returns></returns>
        private SchedulerModule GetMinTotalUseSchedulerBuffer(List<WaferHolderInfo> avaibleWaferHolders,List<SchedulerModule> modules)
        {
            int min = int.MaxValue;
            int index = -1;
            for(int i=0;i<avaibleWaferHolders.Count;i++)
            {
                WaferHolderInfo waferHolderInfo=avaibleWaferHolders[i];
                if(waferHolderInfo.TotalUses<min)
                {
                    min = waferHolderInfo.TotalUses;
                    index = i;
                }
            }
            if(index!=-1)
            {
                return modules[index];
            }
            return null; 
        }
        /// <summary>
        /// 获取最少使用次数的Buffer
        /// </summary>
        /// <param name="avaibleWaferHolders"></param>
        /// <param name="modules"></param>
        /// <returns></returns>
        private WaferHolderInfo GetMinTotalUseWaferHolder(List<WaferHolderInfo> avaibleWaferHolders)
        {
            int min = int.MaxValue;
            int index = -1;
            for (int i = 0; i < avaibleWaferHolders.Count; i++)
            {
                WaferHolderInfo waferHolderInfo = avaibleWaferHolders[i];
                if(IsWaferHolderExsitProcessedWafer(waferHolderInfo))
                {
                    index = i;
                    break;
                }
                if (waferHolderInfo.TotalUses < min)
                {
                    min = waferHolderInfo.TotalUses;
                    index = i;
                }
            }
            if (index != -1)
            {
                return avaibleWaferHolders[index];
            }
            return null;
        }
        /// <summary>
        /// WaferHolder是否存在已经完成的Production Wafer
        /// </summary>
        /// <param name="waferHolderInfo"></param>
        /// <returns></returns>
        private bool IsWaferHolderExsitProcessedWafer(WaferHolderInfo waferHolderInfo)
        {
            if(!string.IsNullOrEmpty(waferHolderInfo.WaferAId))
            {
                WaferInfo waferInfo = WaferManager.Instance.GetWaferByWaferId(waferHolderInfo.WaferAId);
                if(waferInfo!=null&&waferInfo.WaferType==WaferType.Production&&waferInfo.ProcessState==EnumWaferProcessStatus.Completed)
                {
                    return true;
                }
            }
            if (!string.IsNullOrEmpty(waferHolderInfo.WaferBId))
            {
                WaferInfo waferInfo = WaferManager.Instance.GetWaferByWaferId(waferHolderInfo.WaferBId);
                if (waferInfo != null && waferInfo.WaferType == WaferType.Production && waferInfo.ProcessState == EnumWaferProcessStatus.Completed)
                {
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// WaferHolder是否可以去Loader
        /// </summary>
        /// <returns></returns>
        private bool IsWaferHolderCanGotoLoader(WaferHolderInfo waferHolderInfo)
        {
            if(string.IsNullOrEmpty(waferHolderInfo.WaferAId)||string.IsNullOrEmpty(waferHolderInfo.WaferBId))
            {
                return false;
            }
            if(waferHolderInfo.WaferAType==(int)WaferType.Assit||waferHolderInfo.WaferBType==(int)WaferType.Assit)
            {
                return true;
            }
            WaferInfo waferAInfo = WaferManager.Instance.GetWaferByWaferId(waferHolderInfo.WaferAId);
            if(waferAInfo == null)
            {
                return false;
            }
            WaferInfo waferBInfo = WaferManager.Instance.GetWaferByWaferId(waferHolderInfo.WaferBId);
            if(waferBInfo==null)
            {
                return false;
            }
            //Wafer还是裸硅片            
            return waferHolderInfo.IsToLoader;
        }

        /// <summary>
        /// 根据Wafer尺寸获取waferHolder数量
        /// </summary>
        /// <param name="waferSize"></param>
        /// <returns></returns>
        public int GetWaferHolderInfoCountByWaferSize(WaferSize waferSize, string crsType, List<string> chemistries)
        {
            List<WaferHolderInfo> waferHolders = WaferHolderManager.Instance.GetAllWaferHolders();
            int count = 0;
            foreach (WaferHolderInfo info in waferHolders)
            {
                if (info.WaferSize == (int)waferSize && info.Enabled && info.CrsType == crsType && CheckChemistry(info,chemistries))
                {
                    count++;
                }
            }
            return count;
        }
    }
}