Пример #1
0
        } // end of Event

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// Acutal state change of arrival. If patient arrives from waiting list path is set, otherwise
        /// next action is taken.
        /// </summary>
        /// <param name="time">Time the patient arrives</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            //--------------------------------------------------------------------------------------------------
            // In case Patient is returning from special service facility the path
            // has already been set and needs update to next action
            //--------------------------------------------------------------------------------------------------
            if (Patient.OutpatientTreatmentPath != null)
            {
                Patient.OutpatientTreatmentPath.UpdateNextAction();
            }
            else
            {
                Patient.OutpatientTreatmentPath = InputData.CreateOutpatientTreatmentPath(Patient, Admission, ScheduledTime, false);

                ParentControlUnit.AddEntity(Patient);
            } // end if

            if (Patient.OutpatientTreatmentPath.TakeNextAction(simEngine, this, time, ParentControlUnit))
            {
                if (Patient.OccupiedFacility == null || Patient.OccupiedFacility.ParentDepartmentControl != ParentControlUnit)
                {
                    SequentialEvents.Add(Patient.StartWaitingActivity(((ControlUnitOutpatient)ParentControlUnit).WaitingAreaPatientForNextActionType(Patient.OutpatientTreatmentPath.GetCurrentActionType())));
                }
                else
                {
                    ActivityWaitInFacility waitInFacility = new ActivityWaitInFacility(ParentControlUnit, Patient, Patient.OccupiedFacility);
                    SequentialEvents.Add(waitInFacility.StartEvent);
                } // end if
            }     // end if
        }         // end of Trigger
        } // end of Event

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// Overriden state change of the event. The patient path is set and the first action is taken.
        /// </summary>
        /// <param name="time">Time the patient arrives</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            Patient.SpecialFacilityPath = InputData.CreatePatientPath(OriginalRequest.SpecialFacilityAdmissionTypes, Patient, OriginalRequest);

            if (Patient.SpecialFacilityPath.TakeNextAction(simEngine, this, time, ParentControlUnit))
            {
                ActivityWait waitPatient = new ActivityWait(ParentControlUnit,
                                                            Patient,
                                                            (((ControlUnitSpecialServiceModel)ParentControlUnit).WaitingAreaPatientForNextActionType(Patient.SpecialFacilityPath.GetCurrentActionType())));


                SequentialEvents.Add(waitPatient.StartEvent);
            } // end if
        }     // end of Trigger
        } // end of EventInpatientStaffEnterLeave

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// Overrides the state change method, incoming staff is blocked for dispatching if the origin delegate is DelegateSentDocForAssistedTreatment
        /// </summary>
        /// <param name="time">Time the staff member enters or leaves</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            if (!IsEnter)
            {
                Staff.BlockedForDispatching = false;
            } // end if

            if (IsEnter)
            {
                SequentialEvents.Add(Staff.StartWaitingActivity(StaffWaitingArea));

                if (IncomingDelegate != null && IncomingDelegate is DelegateSentDocForAssistedTreatment)
                {
                    Staff.BlockedForDispatching = true;
                }
            } // end if
        }     // end of StateChange
        } // end of Event

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// State change of event. Sends patient to the special service model
        /// </summary>
        /// <param name="time">Time event is triggered</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            ControlUnitManagement jointControl = (ControlUnitManagement)ParentControlUnit.FindSmallestJointControl(Availability.ServiceControl);

            if (Patient != null)
            {
                ActivityMove movePatientToSpecialTreatment
                    = new ActivityMove(jointControl,
                                       Patient,
                                       ParentControlUnit,
                                       Availability.ServiceControl,
                                       ReturnDelegate,
                                       jointControl.InputData.DurationMove(Patient,
                                                                           ParentControlUnit,
                                                                           Availability.ServiceControl));
                SequentialEvents.Add(movePatientToSpecialTreatment.StartEvent);
            } // end if
        }     // end of Trigger
Пример #5
0
        } // end of Event

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// State chage of event. Checks if patient comes from outside of the model. In that case
        /// a new event is triggered. Waiting for assign slot is started.
        /// </summary>
        /// <param name="time">Arriving time</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            if (AdmissionType.IsExtern)
            {
                DateTime      nextArrivalTime;
                Admission     admission;
                EntityPatient newPatient = InputData.GetNextWaitingListPatient(out nextArrivalTime,
                                                                               out admission,
                                                                               ParentControlUnit,
                                                                               time);

                if (newPatient != null)
                {
                    EventOutpatientWaitingListPatientArrival nextArrival =
                        new EventOutpatientWaitingListPatientArrival(ParentControlUnit,
                                                                     OutpatientControlUnit,
                                                                     newPatient,
                                                                     admission,
                                                                     InputData);

                    simEngine.AddScheduledEvent(nextArrival, nextArrivalTime);
                } // end if
            }     // end if

            DateTime earliestTime = (time + TimeSpan.FromDays(AdmissionType.MinDaySpan)).Date;
            DateTime latestTime   = DateTime.MaxValue;

            if (AdmissionType.MaxDaySpan < double.MaxValue)
            {
                latestTime = (time + TimeSpan.FromDays(AdmissionType.MaxDaySpan)).Date;
            }

            ActivityOutpatientWaitingListWaitToAssignSlot waitForAssignment
                = new ActivityOutpatientWaitingListWaitToAssignSlot(ParentControlUnit,
                                                                    Patient,
                                                                    AdmissionType,
                                                                    earliestTime,
                                                                    latestTime);

            SequentialEvents.Add(waitForAssignment.StartEvent);
        } // end of Trigger
Пример #6
0
        } // end of EventType

        #endregion

        #region Trigger

        /// <summary>
        /// Trigger method of the event.
        /// </summary>
        /// <param name="time">Time when event is triggered</param>
        /// <param name="simEngine">SimEngine that executes the model</param>
        public void Trigger(DateTime time, ISimulationEngine simEngine)
        {
            foreach (Entity entity in AffectedEntities)
            {
                // if the parent control unit of the entity is already set it is checked if the
                // parent control unit differs from the control the event is hosted.
                // If it is different it is changed to the parent control of the event and the entity is
                // added to this control unit
                if (entity.ParentControlUnit != null)
                {
                    if (entity.ParentControlUnit != ParentControlUnit)
                    {
                        entity.ParentControlUnit.RemoveEntity(entity);
                        ParentControlUnit.AddEntity(entity);
                    }
                }
                // if the entities parent control is not set it is added to the parent control of the event
                else
                {
                    ParentControlUnit.AddEntity(entity);
                }
            } // endforeach

            // custom state change of the event, cann be overwritten by the user
            StateChange(time, simEngine);

            // the event is logged at the used simulation engine
            simEngine.LogEvent(this);

            // sequential events are triggered, they might be defined by custom state change method.
            foreach (Event seqEvent in SequentialEvents)
            {
                seqEvent.Trigger(time, simEngine);
            } // end foreach

            // The behavior occured flag of the parent control is set to true
            ParentControlUnit.BehaviorOccured = true;

            // sequential eventy are cleared
            SequentialEvents.Clear();
        } // end of Trigger
        } // end of Event

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region StateChange

        /// <summary>
        /// Overriden state change of the event. If the patient is arrving externaly then the next arrival is
        /// scheduled. Else the path is updated and the next/first action is taken from the path.
        /// </summary>
        /// <param name="time">Time the patient arrives</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            // if patient has a path it is updated
            if (Patient.EmergencyTreatmentPath != null)
            {
                Patient.EmergencyTreatmentPath.UpdateNextAction();
            }
            else
            {
                // if patient has no path he is arriving externaly

                // path is created
                Patient.EmergencyTreatmentPath = ((ControlUnitEmergency)ParentControlUnit).InputData.CreateEmergencyPath(Patient);

                // patient is added to control unit
                ParentControlUnit.AddEntity(Patient);

                // arrival of next patient is created and scheduled
                EntityPatient nextPatient = ((ControlUnitEmergency)ParentControlUnit).InputData.GetNextPatient();

                EventEmergencyPatientArrival nextPatientArrival = new EventEmergencyPatientArrival(ParentControlUnit, nextPatient, InputData);

                simEngine.AddScheduledEvent(nextPatientArrival, time + ((ControlUnitEmergency)ParentControlUnit).InputData.PatientArrivalTime(time));
            } // end if

            // next action on path is taken
            if (Patient.EmergencyTreatmentPath.TakeNextAction(simEngine, this, time, ParentControlUnit))
            {
                // possible waiting or waiting in facility is triggered
                if (Patient.OccupiedFacility == null || Patient.OccupiedFacility.ParentDepartmentControl != ParentControlUnit)
                {
                    SequentialEvents.Add(Patient.StartWaitingActivity(((ControlUnitEmergency)ParentControlUnit).WaitingAreaPatientForNextActionType(Patient.EmergencyTreatmentPath.GetCurrentActionType())));
                }
                else
                {
                    ActivityWaitInFacility waitInFacility = new ActivityWaitInFacility(ParentControlUnit, Patient, Patient.OccupiedFacility);
                    SequentialEvents.Add(waitInFacility.StartEvent);
                } // end if
            }     // end if
        }         // end of Trigger
Пример #8
0
        } // end of InputData

        #endregion

        //--------------------------------------------------------------------------------------------------
        // Methods
        //--------------------------------------------------------------------------------------------------

        #region StateChange

        /// <summary>
        /// Overriden state change. Initializes a new arrival and patient paths and first action.
        /// </summary>
        /// <param name="time">Time the patient arrives</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            Patient.OutpatientTreatmentPath =
                InputData.CreateOutpatientTreatmentPath(Patient,
                                                        null,
                                                        time,
                                                        true);

            ParentControlUnit.AddEntity(Patient);

            DateTime nextTime;;

            EntityPatient nextPatient = InputData.GetNextWalkInPatient(out nextTime, ParentControlUnit, time);

            EventOutpatientWalkInPatientArrival nextPatientArrival = new EventOutpatientWalkInPatientArrival(ParentControlUnit, InputData, nextPatient);

            simEngine.AddScheduledEvent(nextPatientArrival, nextTime);

            if (Patient.EmergencyTreatmentPath.TakeNextAction(simEngine, this, time, ParentControlUnit))
            {
                SequentialEvents.Add(Patient.StartWaitingActivity());
            } // end if
        }     // end of StateChange
Пример #9
0
        } // end of EventStaffChange

        #endregion

        //--------------------------------------------------------------------------------------------------
        // State Change
        //--------------------------------------------------------------------------------------------------

        #region Trigger

        /// <summary>
        /// Overrides the state change method, staffing levels will change, for leaving
        /// staff requests for absence are filed, incoming staff is added to the
        /// parent control unit
        /// </summary>
        /// <param name="time">Time the staffing changes</param>
        /// <param name="simEngine">SimEngine responsible for simulation execution</param>
        protected override void StateChange(DateTime time, ISimulationEngine simEngine)
        {
            // foreach leaving staff a request to be absent is filed at their control unit
            // arriving staff is automatically added to the control by the triggering
            // of the event
            foreach (ResourceAssignmentStaff staffAssignment in StaffLeaving)
            {
                ParentDepartmentControl.AddRequest(new RequestBeAbsent(staffAssignment.Resource, time));
                staffAssignment.Resource.StaffOutsideShift = true;
            } // end foreach

            foreach (ResourceAssignmentStaff staffAssignment in StaffAriving)
            {
                staffAssignment.Resource.StaffOutsideShift     = false;
                staffAssignment.Resource.BlockedForDispatching = false;
                staffAssignment.Resource.BaseControlUnit       = ParentDepartmentControl;
                staffAssignment.Resource.AssignmentType        = staffAssignment.AssignmentType;

                if (staffAssignment.OrganizationalUnit == "RootDepartment")
                {
                    ParentDepartmentControl.AddEntity(staffAssignment.Resource);
                }
                else
                {
                    ParentDepartmentControl.OrganizationalUnitPerName[staffAssignment.OrganizationalUnit].AddEntity(staffAssignment.Resource);
                }

                SequentialEvents.Add(staffAssignment.Resource.StartWaitingActivity(ParentDepartmentControl.WaitingRoomForStaff(staffAssignment.Resource)));
            } // end foreach

            DateTime nextTime;

            // schedule the next staff change
            Event nextChange = StaffHandler.GetNextStaffChangingEvent(ParentDepartmentControl, time, out nextTime);

            simEngine.AddScheduledEvent(nextChange, nextTime);
        } // end of Trigger