PunkHPX8/PunkHPX8_RT/Schedulers/SchedulerSequenceManager.cs

using MECF.Framework.Common.RecipeCenter;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using Aitex.Core.Common;
using MECF.Framework.Common.CommonData;
using System.Windows;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Routine;
using PunkHPX8_RT.Modules;
using Aitex.Core.RT.Fsm;
using PunkHPX8_RT.Modules.Dummy;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using MECF.Framework.RT.Core.Equipments;
using MECF.Framework.Common.ProcessCell;
using SecsGem.Core.ItemModel;
using PunkHPX8_RT.Modules.Transporter;
using PunkHPX8_Core;
using Aitex.Core.RT.SCCore;
using PunkHPX8_RT.Modules.SRD;
using PunkHPX8_RT.Devices.EFEM;

namespace PunkHPX8_RT.Schedulers
{
    public class SchedulerSequenceManager : Singleton<SchedulerSequenceManager>   
    {
        #region 常量 
        private const string ENGINEERING = "Engineering";
        private const string PRODUCTION = "Production";
        private const string TRNPA = "TRNPA";
        private const string TRNPB = "TRNPB";
        #endregion
        /// <summary>
        /// 解析LoaderTransporter放至Loader第一次确定TRNP的方向
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <param name="waferCount"></param>
        /// <returns></returns>
        private string AnalyseLoadTransporterSide(SequenceRecipe sequenceRecipe,int productWaferCount,int dummyWaferCount)
        {
            //单片，同时loader两边尺寸不一致
            if ((productWaferCount == 1||dummyWaferCount==1) )
            {
                //recipe使用B面工艺,但loader A面与recipe尺寸一致
                if (sequenceRecipe.LastSingleWaferToSideB )
                {
                    return "TRNPB";
                }
                //recipe使用A面工艺,但loader B面与recipe尺寸一致
                else if (!sequenceRecipe.LastSingleWaferToSideB)
                {
                    return "TRNPB";
                }
            }
            return "TRNPA";
        }

        private string GetReverseTransporterLocation(string strTrn)
        {
            return strTrn == TRNPA ? TRNPB : TRNPA;
        }
        /// <summary>
        /// 检验Loader两边waferSize不一致
        /// </summary>
        /// <returns></returns>
        private bool CheckLoaderWaferSizeNotEqual()
        {
            return false;
        }
        /// <summary>
        /// 创建LoaderTrasporter同步模块消息
        /// </summary>
        /// <param name="tranporter"></param>
        /// <returns></returns>
        private List<SchedulerSyncModuleMessage> GenerateLoaderTransporterSyncModuleMessage(string tranporter)
        {
            List<SchedulerSyncModuleMessage> synModules = new List<SchedulerSyncModuleMessage>();
            SchedulerSyncModuleMessage syncModuleMessage = new SchedulerSyncModuleMessage();
            syncModuleMessage.ModuleEntity = Singleton<RouteManager>.Instance.GetModule<IModuleEntity>(ModuleName.Loader1.ToString());
            syncModuleMessage.parameters = new object[] { tranporter };
            synModules.Add(syncModuleMessage);
            return synModules;
        }
        /// <summary>
        /// 解析Dummy Wafer所有调度工序
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <returns></returns>
        public List<SchedulerSequence> AnalyDummyWaferAllSchedulerSequence(SequenceRecipe sequenceRecipe,WaferInfo waferInfo, ModuleName pufModule,string side)
        {
            waferInfo.LoaderSide = side;
            List<SchedulerSequence> schedulerSequences = new List<SchedulerSequence>();
            int index = 0;
            //DummyCassete至Aligner
            MoveItem moveItem = new MoveItem((ModuleName)waferInfo.Station, waferInfo.Slot, ModuleName.Aligner1, 0, Aitex.Sorter.Common.Hand.Blade1,Aitex.Sorter.Common.Flip.Upper);
            SchedulerSequence secondEfemRobotSequence = CreateEfemRobotSequence(moveItem, null,sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(secondEfemRobotSequence);
            //Aligner
            SchedulerSequence alignerSequence = alignerSequence=CreateAlignerSequence(sequenceRecipe, ref index);

            schedulerSequences.Add(alignerSequence);
            //Aligner至Puf
            MoveItem alignerToPufMoveItem = new MoveItem(ModuleName.Aligner1, 0, pufModule, 1, Aitex.Sorter.Common.Hand.Blade1,Aitex.Sorter.Common.Flip.Upper);
            SchedulerSequence alignerToPufEfemRobotSequence = CreateEfemRobotSequence(alignerToPufMoveItem, null,sequenceRecipe.SubstrateSize, ref index);
            schedulerSequences.Add(alignerToPufEfemRobotSequence);
            SchedulerSequence pufSequence = CreatePufSequence(pufModule,sequenceRecipe, side,true, ref index);
            schedulerSequences.Add(pufSequence);            
            return schedulerSequences;
        }
        /// <summary>
        /// 分析Sequence recipe对应的调度步骤
        /// </summary>
        /// <param name="sequenceRecipe"></param>
        /// <returns></returns>
        private List<SchedulerSequence> AnalyseSequenceRecipeScheduler(SequenceRecipe sequenceRecipe)
        {
            List<SchedulerSequence> schedulerSequences= new List<SchedulerSequence>();
            List<SchedulerSequence> tmpLst = new List<SchedulerSequence>();
            var  processResult = AnalyseLastProcessRecipeIndex(sequenceRecipe.Recipes);
            bool isExistSrd = sequenceRecipe.Recipes.FindIndex(O=>O.ToLower().EndsWith("srd.rcp"))!=-1;
            int lastIndex = isExistSrd ? sequenceRecipe.Recipes.Count - 2 : sequenceRecipe.Recipes.Count - 1;
            for(int i=0;i<sequenceRecipe.Recipes.Count;i++)
            {                
                string item = sequenceRecipe.Recipes[i];
                if(item.ToLower().EndsWith("srd.rcp"))//跳过SRD
                {
                    continue;
                }
                SchedulerSequence schedulerSequence = new SchedulerSequence();
                if (i == 0 && item.ToLower().EndsWith("qdr.rcp"))
                {
                    RinseItem rinsePwtItem = RinseItemManager.Instance.GetPrewetRinseItem();
                    if (rinsePwtItem != null)
                    {
                        schedulerSequence.ModuleName = (ModuleName)Enum.Parse(typeof(ModuleName), rinsePwtItem.ModuleName);
                        schedulerSequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(schedulerSequence.ModuleName);
                    }
                    else
                    {
                        schedulerSequence.ModuleName = ModuleName.Unknown;
                    }
                }
                else
                {
                    schedulerSequence.ModuleName = ModuleName.Unknown;
                }
                schedulerSequence.ModuleType=SequenceRecipeManager.Instance.GetModuleType(item);
                schedulerSequence.SequenceIndex=i;
                schedulerSequence.WaferSize = sequenceRecipe.SubstrateSize;
                MECF.Framework.Common.RecipeCenter.RecipeType recipeType =SequenceRecipeManager.Instance.GetRecipeType(item);
                schedulerSequence.Recipe = SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType,item, recipeType);
                schedulerSequence.SequenceType = sequenceRecipe.SequenceType;
                schedulerSequence.State = RState.Init;
                schedulerSequence.MaterialType = MaterialType.WaferHolder;
                tmpLst.Add(schedulerSequence); 
                if (i != lastIndex)
                {
                    string nextModule = sequenceRecipe.Recipes[i + 1];
                    schedulerSequence.NextModuleType = SequenceRecipeManager.Instance.GetModuleType(nextModule);
                    MECF.Framework.Common.RecipeCenter.RecipeType nextRecipeType = SequenceRecipeManager.Instance.GetRecipeType(nextModule);
                    schedulerSequence.NextRecipe = SequenceRecipeManager.Instance.LoadSequenceTypeRecipe(sequenceRecipe.SequenceType, nextModule, nextRecipeType);
                }
                schedulerSequence.IsProcessSequece = true;
                if(i==processResult.lastIndex)
                {
                    schedulerSequence.IsLastProcessSequence = true;
                }
                
            }
            int index = 0;
            for(int i=0;i<tmpLst.Count;i++)
            {
                tmpLst[i].SequenceIndex = 0;
                schedulerSequences.Add(tmpLst[i]);
                index++;
            }
            return schedulerSequences;
        }
        /// <summary>
        /// 分析最后加工recipe索引
        /// </summary>
        /// <param name="recipes"></param>
        /// <returns></returns>
        private (int lastIndex,List<int> processIndexList) AnalyseLastProcessRecipeIndex(List<string> recipes)
        {
            int index = 0;
            List<int> lst = new List<int>();
            for(int i=0;i<recipes.Count; i++)
            {
                string item=recipes[i];
                if(item.ToLower().EndsWith("dep.rcp"))
                {
                    index = i;
                    if(lst.Contains(i))
                    {
                        lst.Add(i);
                    }
                }
            }
            if(lst.Count==0)
            {
                lst.Add(0);
            }
            return (index,lst);
        }

        /// <summary>
        /// 创建EFEM Robot步骤
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateEfemRobotSequence(MoveItem moveItem,List<SchedulerSyncModuleMessage> synModules,int waferSize,ref int index)
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.EfemRobot);
            sequence.SequenceIndex= index;
            sequence.ModuleName=ModuleName.EfemRobot;
            sequence.State = RState.Init;
            sequence.Recipe = null;
            sequence.ModuleType=ModuleType.EfemRobot;
            sequence.Parameters =moveItem;
            sequence.MaterialType = MaterialType.Wafer;
            sequence.SynchronousModuleMessages = synModules;
            sequence.WaferSize = waferSize;
            index++;
            return sequence;
        }
        /// <summary>
        /// 创建Aligner步骤 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateAlignerSequence(SequenceRecipe recipe,ref int index) 
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(ModuleName.Aligner1);
            sequence.SequenceIndex = index;
            sequence.ModuleName = ModuleName.Aligner1;
            sequence.State = RState.Init;
            sequence.Recipe = recipe;
            sequence.ModuleType = ModuleType.Aligner;
            sequence.Parameters = null;
            sequence.MaterialType = MaterialType.Wafer;
            sequence.WaferSize = sequence.WaferSize;
            index++;
            return sequence;
        }
        /// <summary>
        /// 创建PUF步骤
        /// </summary>
        /// <param name="pufModuleName"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreatePufSequence(ModuleName pufModuleName,SequenceRecipe sequenceRecipe,string side,bool forward,ref int index)
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(pufModuleName);
            sequence.SequenceIndex = index;
            sequence.ModuleName = pufModuleName;
            sequence.State = RState.Init;
            sequence.Recipe = sequenceRecipe;
            sequence.Parameters = null;
            sequence.IsWaitNotify = !forward;
            sequence.ModuleType = ModuleType.PUF;
            sequence.MaterialType = MaterialType.Wafer;
            sequence.WaferSize = sequenceRecipe.SubstrateSize;
            index++;
            return sequence;
        }
        /// <summary>
        /// 创建Loader步骤
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private SchedulerSequence CreateSRDSequence(SrdRecipe recipe,ref int index)
        {
            SchedulerSequence sequence = new SchedulerSequence();
            sequence.SequenceIndex = index;
            sequence.State = RState.Init;
            sequence.Recipe = recipe;
            sequence.ModuleType = ModuleType.SRD;
            sequence.MaterialType = MaterialType.Wafer;
            index++;
            return sequence;
        }
        /// <summary>
        /// 获取可用Dummy slot
        /// </summary>
        /// <param name="moduleType"></param>
        /// <returns></returns>
        public (ModuleName moduleName, int slot) GetAvaibleDummySlots(WaferSize waferSize)
        {
            if (ModuleHelper.IsInstalled(ModuleName.Dummy1))
            {
                DummyEntity dummyEntity = Singleton<RouteManager>.Instance.GetModule<DummyEntity>(ModuleName.Dummy1.ToString());
                DummyDevice dummyDevice = Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(0);
                if (dummyDevice != null && dummyDevice.HasCassette && dummyDevice.WaferSize == waferSize)
                {
                    for (int i = 0; i < dummyEntity.MaxSlotNumber; i++)
                    {
                        if (WaferManager.Instance.CheckNoWafer(ModuleName.Dummy1, i))
                        {
                            return (ModuleName.Dummy1, i);
                        }
                    }
                }
            }
            if (ModuleHelper.IsInstalled(ModuleName.Dummy2))
            {
                DummyEntity dummyEntity = Singleton<RouteManager>.Instance.GetModule<DummyEntity>(ModuleName.Dummy2.ToString());
                DummyDevice dummyDevice = Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(1);
                if (dummyDevice != null && dummyDevice.HasCassette && dummyDevice.WaferSize == waferSize)
                {
                    for (int i = 0; i < dummyEntity.MaxSlotNumber; i++)
                    {
                        if (WaferManager.Instance.CheckNoWafer(ModuleName.Dummy2, i))
                        {
                            return (ModuleName.Dummy2, i);
                        }
                    }
                }
            }
            return (ModuleName.Unknown, -1);
        }


        /// <summary>
        /// 根据模块类型获取可用模块
        /// </summary>
        /// <param name="moduleType"></param>
        /// <returns></returns>
        public ModuleName GetAvaibleModuleCell(string sequenceType,ModuleType moduleType, ModuleName moduleName = ModuleName.Unknown)
        {
            if (ModuleHelper.IsPlatingCell(moduleName))
            {
                List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
                return GetPlatingCellAvaibleRinseModule(entities, moduleName);
            }
            else
            {
                List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(moduleType);
                List<IModuleEntity> avaibles = new List<IModuleEntity>();
                foreach (var item in entities)
                {
                    bool result = CheckAvaibleModule(item,moduleType,sequenceType);
                    if (result)
                    {
                        avaibles.Add(item);
                    }
                }

                return GetMinTimeToReadyModule(avaibles,moduleType);
            }
        }

        /// <summary>
        /// 获取可用的Dryer cell
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="startTime"></param>
        /// <param name="dryerTimeLength"></param>
        /// <returns></returns>
        public ModuleName GetAvaibleDryerCell(string waferHolderId, DateTime startTime, int dryerTimeLength, bool checkConflict)
        {
            List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(ModuleType.Dryer);
            List<IModuleEntity> avaibleEntities = new List<IModuleEntity>();
            foreach (IModuleEntity item in entities)
            {
                if ((item.IsIdle || item.IsBusy) && item.IsAuto)
                {
                    avaibleEntities.Add(item);
                }
            }
            if (checkConflict)
            {
                List<ModuleName> resets = SchedulerDryerTimeManager.Instance.ResetModuleOrderByUsed(avaibleEntities);
                List<IModuleEntity> avaibles = new List<IModuleEntity>();
                foreach (var item in resets)
                {
                    var conflict = SchedulerDryerTimeManager.Instance.CheckDryerConflict(item.ToString(), waferHolderId, startTime, dryerTimeLength);
                    if (!conflict.conflict)
                    {
                        return item;
                    }
                }
            }
            else
            {
                List<ModuleName> resets = SchedulerDryerTimeManager.Instance.ResetModuleOrderBySchedulerEndTime(avaibleEntities);
                if (resets.Count != 0)
                {
                    return resets[0];
                }
            }
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 获取可用的Dryer cell
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="startTime"></param>
        /// <param name="dryerTimeLength"></param>
        /// <returns></returns>
        public ModuleName GetAvaibleQdrCell(string waferHolderId, string platingCellName)
        {
            List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByPlatingCell(platingCellName.ToString());
            if (rinseItems.Count == 0)
            {
                return ModuleName.Unknown;
            }
            List<IModuleEntity> entities = Singleton<RouteManager>.Instance.GetModulesByModuleType(ModuleType.Rinse);
            List<IModuleEntity> avaibles = new List<IModuleEntity>();
            foreach (var item in entities)
            {
                LayoutCellItem cellItem = rinseItems.Find(O => O.ModuleName == item.Module.ToString());
                if (cellItem != null)
                {
                }
            }
            List<ModuleName> resets = SchedulerQdrTimeManager.Instance.ResetModuleOrderBySchedulerEndTime(avaibles);
            if (resets.Count != 0)
            {
                return resets[0];
            }
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 根据化学液计算时间获取可用PlatingCellCell(参考其他PlatingCell剩余时间)
        /// </summary>
        /// <param name="chemistry"></param>
        /// <returns></returns>
        public ModuleName CalculateAvaiblePlatingCellCellByChemistry(string chemistry,string startRinse,string sequenceType,int waferSize,ref bool isExistEnablePlatingCell)
        {
            if(!Enum.TryParse(startRinse,out ModuleName startRinseModule)||!ModuleHelper.IsRinse(startRinseModule))
            {
                startRinse = "";
            }
            isExistEnablePlatingCell = false;
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 根据化学液计算时间获取可用PlatingCellCell(参考其他PlatingCell剩余时间)
        /// </summary>
        /// <param name="chemistry"></param>
        /// <returns></returns>
        public (ModuleName platingCellModule, ModuleName rinseModule) CalculateAvaiblePlatingCellCellByChemistry(string chemistry, string startRinse, string sequenceType, string waferHolderId,
            int waferSize,DateTime startTime, int depRecipeTimeLength, int qdrRecipeTimeLength, bool checkConflict,
            SchedulerModulePartTime platingCellPartTime, SchedulerModulePartTime qdrParTime, ref bool isExistEnablePlatingCell)
        {
            bool isShowLog = SC.GetValue<bool>("Scheduler.IsShowLog");
            if (!Enum.TryParse(startRinse, out ModuleName startRinseModule) || !ModuleHelper.IsRinse(startRinseModule))
            {
                startRinse = "";
            }
            isExistEnablePlatingCell = false;
            return (ModuleName.Unknown, ModuleName.Unknown);
        }
        /// <summary>
        /// 根据化学液获取可用PlatingCell
        /// </summary>
        /// <param name="chemistry"></param>
        /// <param name="sequenceType"></param>
        /// <returns></returns>
        public bool CalculateAvaiblePlatingCellCellByChemistry(string chemistry,string sequenceType,int waferSize)
        {
            return false;
        }
        /// <summary>
        /// 检验Process transporter正在Transfer WH移动至Rinse
        /// </summary>
        /// <returns></returns>
        private bool CheckProcessTransporterTransfering(List<string> rinseList)
        {
            return false;
        }
        /// <summary>
        /// 计算PlatingCell所在Reservoir Busy PlatingCell数量
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        private (bool success,int busyCount) CalculatePlatingCellReservoirAllBusyPlatingCellCount(string platingCellName)
        {
            string reservoirName = ReservoirItemManager.Instance.GetReservoirByPlatingCell(platingCellName);
            if (string.IsNullOrEmpty(reservoirName))
            {
                return (false,0);
            }
            List<string> platingCells = ReservoirItemManager.Instance.GetPlatingCellsByReservoir(reservoirName);
            int count = 0;
            foreach (string item in platingCells)
            {
                if (platingCellName == item)
                {
                    continue;
                }
            }
            return (true,count);
        }
        /// <summary>
        /// 检验独立Rinse是否可用
        /// </summary>
        /// <param name="singleRinseItems"></param>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private bool CheckSingleRinseItemsCanUsed(List<string> singleRinseItems, string platingCellName)
        {
            var result = CalculatePlatingCellReservoirAllBusyPlatingCellCount(platingCellName);
            if(result.success)
            {
                bool transporterTransfering = CheckProcessTransporterTransfering(singleRinseItems);
                if (transporterTransfering)
                {
                    return result.busyCount + 1 < singleRinseItems.Count;
                }
                else
                {
                    return result.busyCount < singleRinseItems.Count;
                }
            }
            return false;
        }
        /// <summary>
        /// 检验共享Rinse是否可用
        /// </summary>
        /// <param name="sharedRinse"></param>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private bool CheckShardRinseCanUse(string sharedRinse, string platingCellName,string startRinse)
        {
            string reservoirName = ReservoirItemManager.Instance.GetReservoirByPlatingCell(platingCellName);
            List<string> shardReservoirs = CellItemManager.Instance.GetReservoirsBySharedRinse(sharedRinse);
            if (shardReservoirs == null || shardReservoirs.Count == 0)
            {
                return false;
            }

            foreach (string reservoir in shardReservoirs)
            {
                if (reservoir==reservoirName)
                {
                    continue;
                }
            }
            return true;
        }
        /// <summary>
        /// 检验可用
        /// </summary>
        /// <param name="item"></param>
        /// <param name="moduleType"></param>
        /// <param name="sequenceType"></param>
        /// <param name="waferHolderId"></param>
        /// <param name="startTime"></param>
        /// <param name="processLength"></param>
        /// <returns></returns>
        public bool CheckAvaiblePlatingCellModule(IModuleEntity item, ModuleType moduleType, string sequenceType, string waferHolderId, DateTime startTime, int processLength, bool checkConflict)
        {
            bool result = CheckAvaibleModule(item, moduleType, sequenceType);
            if (!result)
            {
                return false;
            }
            if (checkConflict)
            {
                var conflict = SchedulerPlatingCellTimeManager.Instance.CheckPlatingCellConflict(item.Module.ToString(), waferHolderId, startTime, processLength);
                return !conflict.conflict;
            }
            else
            {
                return result;
            }
        }
        /// <summary>
        /// 检验模块是否可用
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public bool CheckAvaibleModule(IModuleEntity item,ModuleType moduleType,string sequenceType)
        {
            if (item.IsDisable)
            {
                return false;
            }
            if (!item.IsAuto)
            {
                return false;
            }
            if (item.IsError)
            {
                return false;
            }
            if (item.IsInit)
            {
                return false;
            }
            if (moduleType==ModuleType.PlatingCell)
            {
                if(item.IsProduction && sequenceType == ENGINEERING)
                    return false;
                if (item.IsEngineering && sequenceType == PRODUCTION)
                    return false;
            }
            return true;
        }
        /// <summary>
        /// 获取剩余时间最小的模块
        /// </summary>
        /// <param name="avaibles"></param>
        /// <returns></returns>
        private ModuleName GetMinTimeToReadyModule(List<IModuleEntity> avaibles,ModuleType moduleType)
        {
            if (avaibles.Count == 1)
            {
                return avaibles[0].Module;
            }
            int timeToReady = int.MaxValue;
            IModuleEntity selectedModule = null;
            List<IModuleEntity> idleModuleEtities = new List<IModuleEntity>(); 
            foreach (var item in avaibles)
            {
                if (item.IsIdle)
                {
                    if(moduleType!=ModuleType.PlatingCell)
                    {
                        return item.Module;
                    }
                    idleModuleEtities.Add(item);
                }
                if (item.TimeToReady < timeToReady&&idleModuleEtities.Count==0)
                {
                    timeToReady = item.TimeToReady;
                    selectedModule = item;
                }
            }
            if (idleModuleEtities.Count != 0)
            {
                return GetMinUsagePlatingCell(idleModuleEtities);
            }
            if (selectedModule != null)
            {
                return selectedModule.Module;
            }
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 获取电量最小的PlatingCell
        /// </summary>
        /// <param name="idleModuleEntities"></param>
        /// <returns></returns>
        private ModuleName GetMinUsagePlatingCell(List<IModuleEntity> idleModuleEntities, int depProcessLength, SchedulerModulePartTime platingCellPartTime)
        {
            ModuleName selectedModuleName = ModuleName.Unknown;
            List<string> minDateModuleLst = new List<string>();
            return selectedModuleName;
        }
        /// <summary>
        /// 获取电量最小的PlatingCell
        /// </summary>
        /// <param name="idleModuleEntities"></param>
        /// <returns></returns>
        private ModuleName GetMinUsagePlatingCell(List<IModuleEntity> idleModuleEntities)
        {
            ModuleName selectedModuleName = ModuleName.Unknown;
            return selectedModuleName;
        }
        /// <summary>
        /// 获取PlatingCell可用的Rinse模块
        /// </summary>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private ModuleName GetPlatingCellAvaibleRinseModule(List<IModuleEntity> items, ModuleName platingCellName)
        {
            int platingCellId = CellItemManager.Instance.GetCellIdByModuleName(platingCellName.ToString());
            if (platingCellId == 0)
            {
                return ModuleName.Unknown;
            }
            List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByPlatingCell(platingCellName.ToString());
            if (rinseItems.Count == 0)
            {
                return ModuleName.Unknown;
            }

            return ModuleName.Unknown;
        }
        /// <summary>
        /// 检验PlatingCell可用的Rinse模块
        /// </summary>
        /// <param name="platingCellName"></param>
        /// <returns></returns>
        private ModuleName GetPlatingCellAvaibleEmptyRinseModule(List<IModuleEntity> items, ModuleName platingCellName)
        {
            int platingCellId = CellItemManager.Instance.GetCellIdByModuleName(platingCellName.ToString());
            if (platingCellId == 0)
            {
                return ModuleName.Unknown;
            }
            List<LayoutCellItem> rinseItems = CellItemManager.Instance.GetRinseItemsByPlatingCell(platingCellName.ToString());
            if (rinseItems.Count == 0)
            {
                return ModuleName.Unknown;
            }
            return ModuleName.Unknown;
        }
        /// <summary>
        /// 获取上一个PlatingCell
        /// </summary>
        /// <param name="sequenceIndex"></param>
        /// <param name="sequences"></param>
        /// <returns></returns>
        public ModuleName GetPrePlatingCellModuleName(int sequenceIndex,List<SchedulerSequence> sequences)
        {
            for(int i = sequenceIndex - 1; i >= 0; i--)
            {
                SchedulerSequence schedulerSequence= sequences[i];
                if (schedulerSequence.ModuleType == ModuleType.PlatingCell && ModuleHelper.IsPlatingCell(schedulerSequence.ModuleName))
                {
                    return schedulerSequence.ModuleName;
                }
            }
            return ModuleName.Unknown;
        }
    }


}