Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="aeqp"/>
        /// <param name="hb"/>
        /// <param name="handled"/>
        /// <param name="prevReturnValue"/>
        /// <returns/>
        public bool IS_NEED_SETUP0(Mozart.SeePlan.Simulation.AoEquipment aeqp, Mozart.SeePlan.Simulation.IHandlingBatch hb, ref bool handled, bool prevReturnValue)
        {
            FabLot         lot = hb.Sample as FabLot;
            FabAoEquipment eqp = aeqp.ToFabAoEquipment();

            bool isNeedSetup = ResHelper.IsNeedSetup(eqp, lot);

            return(isNeedSetup);
        }
Example #2
0
        /// <summary>
        /// </summary>
        /// <param name="entity"/>
        /// <param name="now"/>
        /// <param name="target"/>
        /// <param name="factor"/>
        /// <param name="ctx"/>
        /// <returns/>
        public WeightValue MAX_MOVE_LIMIT_PRIORITY(Mozart.Simulation.Engine.ISimEntity entity, DateTime now, Mozart.Simulation.Engine.ActiveObject target, Mozart.SeePlan.DataModel.WeightFactor factor, Mozart.SeePlan.Simulation.IDispatchContext ctx)
        {
            if (factor.Factor == 0)
            {
                return(new WeightValue(0));
            }

            var eqp = target as FabAoEquipment;

            var last = eqp.GetLastPlan();             //eqp.LastPlan;

            if (last == null)
            {
                return(new WeightValue(0));
            }

            FabLot lot = entity as FabLot;

            decimal limitQty = (decimal)factor.Criteria[0];

            if (limitQty == decimal.MaxValue)
            {
                return(new WeightValue(0));
            }

            bool isNeedSetup = ResHelper.IsNeedSetup(eqp, lot);

            if (eqp.ContinuousQty > limitQty)
            {
                if (isNeedSetup)
                {
                    return(new WeightValue(factor.Factor));
                }
            }

            string desc = string.Format("[LIMIT:{0}, Cnt:{1}, SETUP:{2}]", limitQty, eqp.ContinuousQty, isNeedSetup);

            return(new WeightValue(0, desc));
        }
Example #3
0
        public IHandlingBatch[] SELECT1(DispatcherBase db, AoEquipment aeqp, IList <IHandlingBatch> wips, ref bool handled, IHandlingBatch[] prevReturnValue)
        {
            if (InputMart.Instance.GlobalParameters.ApplyFlexialePMSchedule == false)
            {
                return(prevReturnValue);
            }

            if (prevReturnValue == null)
            {
                return(prevReturnValue);
            }

            var list = aeqp.DownManager.GetStartScheduleItems(Time.MaxValue);

            if (list == null || list.Count == 0)
            {
                return(prevReturnValue);
            }

            FabLot lot = prevReturnValue[0] as FabLot;

            var eqp     = aeqp.ToFabAoEquipment();
            var proc    = eqp.Processes[0];
            var outTime = proc.GetUnloadingTime(lot);

            bool isLast      = eqp.IsLastPlan(lot);
            bool isNeedSetup = ResHelper.IsNeedSetup(eqp, lot);

            foreach (var item in list)
            {
                var schedule = item.Tag as PeriodSection;
                var isPM     = schedule is PMSchedule;

                if (isPM == false)
                {
                    continue;
                }

                var pm = schedule as FabPMSchedule;
                var reaminNextPMStart = pm.StartTime - eqp.NowDT;

                //하루 이내만 조정
                if (reaminNextPMStart.TotalDays > 1)
                {
                    continue;
                }

                bool          isAdjust = false;
                FabPMSchedule adjust   = pm.Clone() as FabPMSchedule;

                if (isLast)
                {
                    if ((DateTime)outTime < pm.LimitDelayTime && outTime > pm.StartTime)
                    {
                        adjust.StartTime      = (DateTime)outTime;
                        adjust.EndTime        = adjust.StartTime.AddMinutes(pm.InputDuration.TotalMinutes);
                        adjust.Description    = "DELAY";
                        adjust.AllowAheadTime = (float)(outTime - eqp.Now).TotalMinutes;
                        adjust.ScheduleType   = DownScheduleType.ShiftBackward;

                        aeqp.DownManager.AdjustEvent(item, adjust);
                        isAdjust = true;
                    }
                }
                else
                {
                    if (reaminNextPMStart.TotalMinutes < pm.AllowAheadTime)
                    {
                        prevReturnValue  = null;
                        adjust.StartTime = aeqp.NowDT;
                        adjust.EndTime   = adjust.StartTime.AddMinutes(pm.InputDuration.TotalMinutes);

                        if (adjust.Description != "DELAY")
                        {
                            adjust.Description = "AHEAD";
                        }

                        adjust.IsNeedAdjust = false;

                        aeqp.DownManager.AdjustEvent(item, adjust);
                        isAdjust = true;
                    }
                }

                if (isAdjust == false && pm.StartTime < outTime)
                {
                    float setupTime = 0f;
                    if (isNeedSetup)
                    {
                        setupTime = SetupMaster.GetSetupTime(aeqp, lot);
                    }

                    adjust.StartTime = (DateTime)(outTime + Time.FromMinutes(setupTime));
                    adjust.EndTime   = adjust.StartTime.AddMinutes(pm.InputDuration.TotalMinutes);

                    aeqp.DownManager.AdjustEvent(item, adjust);
                }
            }

            //var data = aeqp.DownManager.GetStartScheduleItems(Time.MaxValue);
            return(prevReturnValue);
        }