enhance throughput and skip repeat loadlock pumping/venting.

Venus/Venus_RT/Devices/TM/JetTM.cs

@@ -382,7 +382,7 @@ namespace Venus_RT.Devices
                 if (rotateModule.Length == 3)
                 {
                     ModuleName rotModule = ModuleHelper.Converter(rotateModule);
-                    if (ModuleHelper.IsPm(rotModule) || ModuleHelper.IsLoadLock(rotModule))
+                    if ((ModuleHelper.IsPm(rotModule) || ModuleHelper.IsLoadLock(rotModule)) && rotModule != mod)
                     {
                         PreRotateModules.Add(mod, rotModule);
                     }

Venus/Venus_RT/Modules/SystemDispatcher.cs

@@ -852,6 +852,7 @@ namespace Venus_RT.Modules
     {
         private List<ControlJobInfo> _lstControlJobs = new List<ControlJobInfo>();
         private List<ProcessJobInfo> _lstProcessJobs = new List<ProcessJobInfo>();
+        private Queue<ControlJobInfo> _qePollingJobs = new Queue<ControlJobInfo>();
 
         private List<WaferTask> _lstWaferTasks = new List<WaferTask>();
         private Dictionary<ModuleName, ModuleTask> _dictModuleTask = new Dictionary<ModuleName, ModuleTask>();
@@ -1400,6 +1401,7 @@ namespace Venus_RT.Modules
             _lstControlJobs.Clear();
             _lstProcessJobs.Clear();
             InUseRecipes.Clear();
+            _qePollingJobs.Clear();
             _cycleState = RState.End;
         }
 
@@ -1662,6 +1664,19 @@ namespace Venus_RT.Modules
                         // parallelly start the not intersect job
                         RunControlJob(queueJob);
                     }
+                    else
+                    {
+                        foreach(var cj in runningJobs)
+                        {
+                            if(!_qePollingJobs.Contains(cj))
+                                _qePollingJobs.Enqueue(cj);
+                        }
+
+                        RunControlJob(queueJob);
+
+                        if (!_qePollingJobs.Contains(queueJob))
+                            _qePollingJobs.Enqueue(queueJob);
+                    }
                 }
             }
 
@@ -1742,7 +1757,23 @@ namespace Venus_RT.Modules
 
         private bool RunControlJob(ControlJobInfo cj)
         {
-            switch(cj.JetState)
+            // polling the sequencial jobs
+            if (_qePollingJobs.Contains(cj))
+            {
+                if (_qePollingJobs.First() == cj)
+                {
+                    if ( !cj.LotWafers.Exists(wafer => !wafer.IsEmpty && wafer.NextSequenceStep == 0) && 
+                            ( (!IsCtrlJobNeedPostClean(cj) && !_lstWaferTasks.Exists(wt => !string.IsNullOrEmpty(wt.wtwCleanRecipe) && (_qePollingJobs.Count <= 1 || !IsCtrlJobNeedPreClean(_qePollingJobs.ElementAt(1)))) ) || 
+                                (IsAllProcessJobComplete(cj) && IsPostJobCleanDone(cj))))
+                    {
+                        _qePollingJobs.Dequeue();
+                        _qePollingJobs.Enqueue(cj);
+                    }
+                }
+            }
+
+
+            switch (cj.JetState)
             {
                 case EnumJetCtrlJobState.Quequed:
                     {
@@ -1882,6 +1913,20 @@ namespace Venus_RT.Modules
                 else
                 {
                     cj.SetState(EnumControlJobState.Completed);
+                    if (_qePollingJobs.Contains(cj))
+                    {
+                        Queue<ControlJobInfo> removedPolingJobs = new Queue<ControlJobInfo>();
+                        foreach (var pj in _qePollingJobs)
+                        {
+                            if (pj != cj)
+                                removedPolingJobs.Enqueue(pj);
+                        }
+
+                        if(removedPolingJobs.Count > 1)
+                            _qePollingJobs = removedPolingJobs;
+                        else
+                            _qePollingJobs.Clear();
+                    }
                 }
             }
             else
@@ -2121,6 +2166,9 @@ namespace Venus_RT.Modules
             {
                 foreach(var runningJob in runningJobs)
                 {
+                    if (_qePollingJobs.Contains(runningJob) && _qePollingJobs.First() != runningJob)
+                        continue;
+
                     foreach (var wafer in runningJob.LotWafers)
                     {
                         if (wafer.IsEmpty || wafer.ProcessJob == null)
@@ -2145,6 +2193,9 @@ namespace Venus_RT.Modules
 
                 foreach (var runningJob in runningJobs)
                 {
+                    if (_qePollingJobs.Contains(runningJob) && _qePollingJobs.First() != runningJob)
+                        continue;
+
                     foreach (var wafer in runningJob.LotWafers)
                     {
                         if (wafer.IsEmpty || wafer.ProcessJob == null)

Venus/Venus_RT/Modules/TM/MFPumpRoutine.cs

@@ -28,6 +28,7 @@ namespace Venus_RT.Modules.TM
         private readonly JetTM _JetTM;
         private int _forelinePressure = 200;
         private bool _pumpIsRunning;
+        private bool _skipRepeatPump = false;
         public MFPumpRoutine(JetTM jetTM, ModuleName mod) : base(mod)
         {
             _JetTM = jetTM;
@@ -52,6 +53,10 @@ namespace Venus_RT.Modules.TM
                 else
                     _switchLLPumpDelay = 0;
 
+                _skipRepeatPump = false;
+                if (ModuleHelper.IsLoadLock(Module) && IsPressureReady())
+                    _skipRepeatPump = true;
+
                 //前端压力值高于某个数值
                 _forelinePressure = SC.GetValue<int>($"{Module}.PumpForelinePressureLimit");
 
@@ -69,6 +74,14 @@ namespace Venus_RT.Modules.TM
 
         public RState Monitor()
         {
+            if (_skipRepeatPump)
+            {
+                Notify($" pressure: {_JetTM.GetModulePressure(Module)} is ready, skip the the pumping routine.");
+                ClosePumpValves();
+                return RState.End;
+            }
+                
+
             Runner.Wait(PumpStep.kWaitPeerModule,      WaitPeerModule,                                                                                             _delay_60s)
                 .Run(PumpStep.kSoftPump,               OpenSoftPump,           () => { return _JetTM.GetModulePressure(Module) < _pumpCrossingPressure; },         _pumpingTimeout)
                 .Run(PumpStep.kFastPump,               SwitchFastPump,         IsPressureReady,                                                                    _pumpingTimeout)

Venus/Venus_RT/Modules/TM/MFVentRoutine.cs

@@ -3,6 +3,7 @@ using Aitex.Core.RT.SCCore;
 using Venus_RT.Devices;
 using MECF.Framework.Common.Equipment;
 using Venus_Core;
+using System.Runtime.InteropServices.WindowsRuntime;
 
 namespace Venus_RT.Modules.TM
 {
@@ -29,6 +30,7 @@ namespace Venus_RT.Modules.TM
         private int _ventTimeDelay = 1;
         private bool _needCooling = false;
         private double _coolingMFCFlow = 0;
+        private bool _skipRepeatVent = false;
         public MFVentRoutine(JetTM jetTM, ModuleName mod) : base(mod)
         {
             _JetTM = jetTM;
@@ -43,6 +45,10 @@ namespace Venus_RT.Modules.TM
                 _coolingMFCFlow = SC.GetValue<double>($"{Module}.Cooling.MFCFlow");
             }
 
+            _skipRepeatVent = false;
+            if ((ModuleHelper.IsLoadLock(Module)) && !_needCooling && IsPressureReady())
+                _skipRepeatVent = true; ;
+
             _JetTM.TurnSoftPumpValve(Module, false);
             _JetTM.TurnFastPumpValve(Module, false);
             _JetTM.TurnPurgeValve(Module, false);
@@ -64,6 +70,14 @@ namespace Venus_RT.Modules.TM
 
         public RState Monitor()
         {
+            if (_skipRepeatVent)
+            {
+                Notify($" pressure: {_JetTM.GetModulePressure(Module)} is ready, skip the the venting routine.");
+                CloseVentValve();
+                CloseExhaustValve();
+                return RState.End;
+            }
+
             Runner.Run(VentStep.OpenSoftVent,       OpenSoftVentValve,      IsSoftVentEnd)
                   .Run(VentStep.SwitchFastVent,     SwitchFastVentValve,    IsPressureReady,    _ventingTimeout)
                   .Delay(VentStep.Delay,            _ventTimeDelay)
@@ -185,6 +199,8 @@ namespace Venus_RT.Modules.TM
                 }
                 _JetTM.TurnPurgeValve(Module, false);
                 _JetTM.TurnExhaustValve(Module, false);
+
+                Notify("Cooling done");
             }
         }
     }

Venus/Venus_Simulator/Instances/SimulatorSystem.cs

@@ -2469,10 +2469,6 @@ namespace Venus_Simulator.Instances
         }
         void MonitorMFKepler2200Pressure()
         {
-            //if (SimulatorJetTM.CurrentTM == JetTMType.Venus)
-            //{
-
-
             string LLA_AI_ChamberPressure = "AI_LLA_CHB_Pressure";
             string LLB_AI_ChamberPressure = "AI_LLB_CHB_Pressure";
             string TM_AI_ChamberPressure = "AI_TM_CHB_Pressure";
@@ -2502,29 +2498,35 @@ namespace Venus_Simulator.Instances
             float getAiValue_LLB_ChamberPressure = GetAiValue($"{mod}.{LLB_AI_ChamberPressure}");
             float getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");
 
-
-
             if (LLA_fast_pump_vlv.Value || LLA_soft_pump_vlv.Value)
             {
-                if (getAiValue_LLA_ChamberPressure > 10000)
+                if (getAiValue_LLA_ChamberPressure > 20000)
                 {
-                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 30000);
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 12000);
+                }
+                else if(getAiValue_LLA_ChamberPressure > 10000)
+                {
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 3000);
                 }
                 else if (getAiValue_LLA_ChamberPressure <= 10000)
                 {
-                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 1500);
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") - 500);
                 }
             }
 
             if (LLB_fast_pump_vlv.Value || LLB_soft_pump_vlv.Value)
             {
-                if (getAiValue_LLB_ChamberPressure > 10000)
+                if (getAiValue_LLB_ChamberPressure > 20000)
                 {
-                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 30000);
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 12000);
+                }
+                else if (getAiValue_LLB_ChamberPressure > 10000)
+                {
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 3000);
                 }
                 else if (getAiValue_LLB_ChamberPressure <= 10000)
                 {
-                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 1500);
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") - 500);
                 }
             }
 
@@ -2543,29 +2545,36 @@ namespace Venus_Simulator.Instances
 
             if (LLA_fast_Vent_vlv.Value || LLA_soft_Vent_vlv.Value)
             {
-                if (getAiValue_LLA_ChamberPressure > 10000)
+                if (getAiValue_LLA_ChamberPressure > 20000)
                 {
-                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 30000);
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 13000);
+                }
+                else if (getAiValue_LLA_ChamberPressure > 10000)
+                {
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 2100);
                 }
                 else if (getAiValue_LLA_ChamberPressure <= 10000)
                 {
-                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 1500);
+                    SetAiValue($"{mod}.{LLA_AI_ChamberPressure}", GetAiValue($"{mod}.{LLA_AI_ChamberPressure}") + 500);
                 }
             }
 
             if (LLB_fast_Vent_vlv.Value || LLB_soft_Vent_vlv.Value)
             {
-                if (getAiValue_LLB_ChamberPressure > 10000)
+                if (getAiValue_LLB_ChamberPressure > 20000)
                 {
-                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 30000);
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 13000);
+                }
+                else if (getAiValue_LLB_ChamberPressure > 10000)
+                {
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 2100);
                 }
                 else if (getAiValue_LLB_ChamberPressure <= 10000)
                 {
-                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 1500);
+                    SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", GetAiValue($"{mod}.{LLB_AI_ChamberPressure}") + 500);
                 }
             }
 
-
             if (TM_fast_Vent_vlv.Value || TM_soft_Vent_vlv.Value)
             {
                 if (getAiValue_TM_ChamberPressure > 10000)
@@ -2597,7 +2606,7 @@ namespace Venus_Simulator.Instances
             }
             else if (getAiValue_LLB_ChamberPressure < 3)
             {
-                SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", 3);
+                SetAiValue($"{mod}.{LLB_AI_ChamberPressure}", 0.5F);
             }
 
             getAiValue_TM_ChamberPressure = GetAiValue($"{mod}.{TM_AI_ChamberPressure}");