/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="parentControlUnit">Parent control unit, either a health care department control unit or a organizational unit</param>
/// <param name="input">Input data of department model</param>
/// <param name="patient">Patient receiving service</param>
/// <param name="resources">Resources included in the activity</param>
/// <param name="type">Type of activity (e.g. emergency action type)</param>
/// <param name="patientPath">The current path of the patient (can vary for outpatient or emergency paths)</param>
public ActivityHealthCareAction(ControlUnit parentControlUnit,
IInputHealthCareDepartment input,
EntityPatient patient,
ResourceSet resources,
T type,
PatientPath <T> patientPath)
: base(parentControlUnit,
"ActivityHealthCareAction",
type.IsPreemptable)
{
_inputData = input;
_patient = patient;
_actionType = type;
_resourceSet = resources;
_patientPath = patientPath;
// in case that the parent control unit is a organizational control
// the parent department control is set
if (parentControlUnit is ControlUnitHealthCareDepartment)
{
_parentDepartmentControl = parentControlUnit as ControlUnitHealthCareDepartment;
}
else if (parentControlUnit is ControlUnitOrganizationalUnit)
{
_parentDepartmentControl = ((ControlUnitOrganizationalUnit)parentControlUnit).ParentDepartmentControl as ControlUnitHealthCareDepartment;
}
} // end of ActivityHealthCareAction
public bool NeedInpatientDiagnosticTest(EntityPatient patient, out SpecialFacilityAdmissionTypes treatment)
{
treatment = null;
return(false);
//if (DiagnosticTests == null)
//{
// DiagnosticTests = new Dictionary<string, SpecialFacilityTreatmentTypes>();
// DiagnosticTests.Add("DiagnosticsCTTreatment", new SpecialFacilityTreatmentTypes("DiagnosticsCTTreatment"));
// DiagnosticTests.Add("DiagnosticsXRayTreatment", new SpecialFacilityTreatmentTypes("DiagnosticsXRayTreatment"));
// DiagnosticTests.Add("DiagnosticsMRITreatment", new SpecialFacilityTreatmentTypes("DiagnosticsMRITreatment"));
//} // end if
//double test = MathTool.Distributions.Instance.RandomNumberGenerator.NextDouble() / ((double)patient.NumberDiagnosticTests + 1);
//if (test >= 0.5)
//{
// if (test <= 0.95)
// {
// treatment = DiagnosticTests["DiagnosticsXRayTreatment"];
// return true;
// }
// else if (test <= 0.99)
// {
// treatment = DiagnosticTests["DiagnosticsCTTreatment"];
// return true;
// }
// else
// {
// treatment = DiagnosticTests["DiagnosticsMRITreatment"];
// return true;
// } // end if
//}
//else
// return false;
} // end of NeedDiagnosticTest
} // end of PossibleChangeWard
#endregion
//--------------------------------------------------------------------------------------------------
// Custom Methods
//--------------------------------------------------------------------------------------------------
#region ChooseDoctor
private EntityDoctor ChooseDoctor(EntityPatient patient, ActivityRequest request)
{
IReadOnlyList <EntityDoctor> doctors = ControlledDoctors;
foreach (EntityDoctor doctor in doctors)
{
if ((doctor.IsWaiting() || doctor.IsInOnlyActivity("ActivityInpatientDoctorOrganizationalWork")) &&
!doctor.BlockedForDispatching)
{
return(doctor);
}
} // end foreach
if (request is RequestInpatientActivity && ((RequestInpatientActivity)request).Activity == "ActivityInpatientEmergencyTreatment")
{
foreach (EntityDoctor doctor in doctors)
{
if (doctor.IsWaitingOrPreEmptable())
{
return(doctor);
}
} // end foreach
} // end if
return(null);
} // end of ChooseDoctor
} // end of InputData
#endregion
//--------------------------------------------------------------------------------------------------
// Enter Leave
//--------------------------------------------------------------------------------------------------
#region EntityEnterControlUnit
public override Event EntityEnterControlUnit(DateTime time, ISimulationEngine simEngine, Entity entity, IDelegate originDelegate)
{
if (entity is EntityHealthCareStaff)
{
return(new EventControlUnitStaffEnterLeave(this, true, (EntityStaff)entity, originDelegate, WaitingRoomForStaff((EntityHealthCareStaff)entity)));
}
EntityPatient patient = (EntityPatient)entity;
if (originDelegate is RequestSpecialFacilitiyService)
{
return(new EventOutpatientArrival(this,
patient,
time,
InputData,
null));
}
else if (originDelegate is RequestMoveOutpatient)
{
RequestMoveOutpatient outDel = (RequestMoveOutpatient)originDelegate;
return(new EventOutpatientWaitingListPatientArrival(
WaitingListControlUnit,
this,
patient,
outDel.OutpatientAdmission,
InputData));
} // end if
return(null);
} // end of EntityEnterControlUnit
/// <summary>
/// Initialization: Patient arrival stream for waiting list patients is initialized.
/// If dispatching is done at discrete events this stream is initialized as well.
/// </summary>
/// <param name="startTime">Time the simulation starts</param>
/// <param name="simEngine">SimEngine that handles the simulation run</param>
protected override void CustomInitialize(DateTime startTime, ISimulationEngine simEngine)
{
WaitingListSchedule.Initialize(startTime);
AddEntity((EntityWaitingListSchedule)WaitingListSchedule);
DateTime nextArrivalTime;
Admission admission;
EntityPatient newPatient = InputData.GetNextWaitingListPatient(out nextArrivalTime, out admission, this, startTime);
if (newPatient != null)
{
EventOutpatientWaitingListPatientArrival nextArrival =
new EventOutpatientWaitingListPatientArrival(this,
(ControlUnitOutpatient)ParentControlUnit,
newPatient,
admission,
InputData);
simEngine.AddScheduledEvent(nextArrival, nextArrivalTime);
} // end if
WaitingListSchedule.ReadyForDispatch = true;
if (AssigningSlotsAtEvents)
{
EventOutpatientStartDispatching nextDispatch = new EventOutpatientStartDispatching(this, WaitingListSchedule, InputData);
simEngine.AddScheduledEvent(nextDispatch, InputData.NextDispatching(startTime));
WaitingListSchedule.ReadyForDispatch = false;
}
} // end of Initialize
} // end of PatientArrivalTime
#endregion
#region PatientActionTime
/// <summary>
/// Activity duriations, here modeled with exponential distributions independent from the patient conditions,
/// just dependent on the action performed
/// </summary>
/// <param name="patient">Patient participating action</param>
/// <param name="resources">Resources involved in action</param>
/// <param name="actionType">Type of action</param>
/// <returns>Time span that represent the duration of the action</returns>
public override TimeSpan PatientActionTime(EntityPatient patient,
ResourceSet resources,
ActionTypeClass actionType)
{
if (actionType.Type == "BedPlacement")
{
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(1)));
}
if (actionType.Type == "Triage")
{
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(5)));
}
if (actionType.Type == "Register")
{
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(5)));
}
if (actionType.Type == "Assessment")
{
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(10)));
}
if (actionType.Type == "Treatment")
{
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(15)));
}
return(TimeSpan.FromMinutes(Distributions.Instance.Exponential(15)));
} // end of PatientEmergencyTreatmentTime
//--------------------------------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------------------------------
#region Constructor
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="actions">List of actions that have to be performed along path</param>
/// <param name="parentPatient">Patient for whom the path is generated</param>
public PatientPath(List <T> actions, EntityPatient parentPatient)
{
_actions = actions;
_currentActionType = actions.First();
_currentPosition = 0;
_parentPatient = parentPatient;
} // end of PatientPath
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="patient">Patient requesting the service</param>
/// <param name="degreeOfCompletion">In case a activity was pre-empted</param>
/// <param name="actionType">The requested action type</param>
/// <param name="time">Time the request is filed</param>
/// <param name="resources">There maybe a pre-defined resource set for the activity, e.g. corresponding doctors</param>
public RequestEmergencyAction(EntityPatient patient,
double degreeOfCompletion,
EmergencyActionTypeClass actionType,
DateTime time,
ResourceSet resources)
: base(patient, degreeOfCompletion, actionType, time, resources)
{
} // end of RequestEmergencyAssistedTreatment
} // end of NoShowForAppointment
#endregion
#region PatientArrivalDeviationFromSlotTime
/// <summary>
/// Creates a time deviation of the patient arrival time and the original slot time, e.g. patient is late or early. Currently implements a
/// triangular distribution with parameters defined in the admission definition
/// </summary>
/// <param name="patient">Patient for appointment</param>
/// <param name="admission">Admission type the patient is showing up for</param>
/// <returns>A positive or negative time span that determines the lateness or earliness of a patient</returns>
public TimeSpan PatientArrivalDeviationFromSlotTime(EntityPatient patient, Admission admission)
{
XMLAdmissionDefinition admissionDef = AdmissionDefinitionPerAdmissionType[admission.AdmissionType.Identifier];
return(TimeSpan.FromMinutes(Distributions.Instance.TriangularDistribution(admissionDef.ShowUpDeviationTriangularEarly,
admissionDef.ShowUpDeviationTriangularMean,
admissionDef.ShowUpDeviationTriangularLate)));
} // end of PatientArrivalDeviationFromSlotTime
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Parent emergency control unit</param>
/// <param name="patient">Patient leaving</param>
/// <param name="input">Emergency input data</param>
public EventEmergencyPatientLeave(ControlUnit parentControlUnit,
EntityPatient patient,
IInputEmergency input)
: base(EventType.Standalone, parentControlUnit)
{
_inputData = input;
_patient = patient;
} // end of Event
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Control unit to host acitivity</param>
/// <param name="patient">Patient that is waiting</param>
/// <param name="facility">Facility occupied by waiting patient</param>
public ActivityWaitInFacility(ControlUnit parentControlUnit,
EntityPatient patient,
EntityTreatmentFacility facility)
: base(parentControlUnit, "ActivityWaitInFacility", false)
{
_patient = patient;
_facility = facility;
} // end of Activity
} // end of ControlUnit
#endregion
#region Initialize
/// <summary>
/// Initializes patient stream
/// </summary>
/// <param name="startTime">Start time of the simulation model</param>
/// <param name="simEngine">SimEngine responsible for simulation execution</param>
protected override void CustomInitialize(DateTime startTime, ISimulationEngine simEngine)
{
EntityPatient patient = InputData.GetNextPatient();
EventEmergencyPatientArrival firstPatient = new EventEmergencyPatientArrival(this, patient, InputData);
simEngine.AddScheduledEvent(firstPatient, startTime + InputData.PatientArrivalTime(startTime));
} // end of Initialize
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="actions">Action types that form path</param>
/// <param name="originalRequest">Service request associated</param>
/// <param name="patient">Parent patient</param>
public SpecialServicePatientPath(
List <SpecialServiceActionTypeClass> actions,
RequestSpecialFacilitiyService originalRequest,
EntityPatient patient)
: base(actions, patient)
{
_originalRequest = originalRequest;
} // end of EmergencyPatientPath
//--------------------------------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------------------------------
#region Constructor
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="parentControlUnit">Parent outpatient control</param>
/// <param name="patient">Arriving patient</param>
/// <param name="inputData">Corresponding input data</param>
public EventOutpatientWalkInPatientArrival(ControlUnit parentControlUnit,
IInputOutpatient inputData,
EntityPatient patient)
: base(EventType.Standalone, parentControlUnit)
{
_patient = patient;
_inputData = inputData;
} // end of EventOutpatientWalkInPatientArrival
} // end of InpatientTreatmentIsPreemptable
#endregion
#region CreateOutpatientAdmission
public OutpatientAdmissionTypes CreateOutpatientAdmission(EntityPatient patient)
{
return(null);
//if (MathTool.Distributions.Instance.RandomNumberGenerator.NextDouble() >= 0.3)
// return null;
//return new OutpatientAdmissionTypes("OutpatientInternalAdmissions", false, false);
} // end of CreateOutpatientAdmission
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="activity">Request for activity type</param>
/// <param name="origin"></param>
/// <param name="time">Time request was filed</param>
/// <param name="patient">Patient that is transfered</param>
/// <param name="originControlUnit">Origin control unit</param>
/// <param name="inpatientAdmission">Admission type</param>
public RequestMoveInpatient(Entity[] origin,
DateTime time,
EntityPatient patient,
ControlUnit originalControlUnit,
Admission inpatientAdmission)
: base("ActivityMove", origin, time, patient, originalControlUnit)
{
_inpatientAdmission = inpatientAdmission;
} // end region
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="originControlUnit">Control unit that filed request</param>
/// <param name="patient">Patient associated with request</param>
/// <param name="time">Time request was filed</param>
/// <param name="type">Type of service requested</param>
public RequestSpecialFacilitiyService(ControlUnit originControlUnit,
EntityPatient patient,
DateTime time,
SpecialServiceAdmissionTypes type)
{
_specialFacilityAdmissionTypes = type;
_patient = patient;
_originControlUnit = originControlUnit;
} // end of RequestDiagnosticTreatment
public RequestSpecialFacilityAction(EntityPatient patient,
double degreeOfCompletion,
SpecialServiceActionTypeClass actionType,
DateTime time,
ResourceSet resources)
: base(patient, degreeOfCompletion, actionType, time, resources)
{
_actionType = actionType;
} // end of RequestDiagnosticTreatment
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="actions">Action types that form path</param>
/// <param name="inpatientAdmission">Possible inpatient admission of path</param>
/// <param name="outpatientAdmission">Possible outpatient admission of path</param>
/// <param name="patient">Parent patient</param>
public EmergencyPatientPath(List <EmergencyActionTypeClass> actions,
Admission inpatientAdmission,
Admission outpatientAdmission,
EntityPatient patient)
: base(actions, patient)
{
_inpatientAdmission = inpatientAdmission;
_outpatientAdmission = outpatientAdmission;
} // end of EmergencyPatientPath
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="activity">Request for activity type</param>
/// <param name="origin"></param>
/// <param name="time">Time request was filed</param>
/// <param name="patient">Patient that is transfered</param>
/// <param name="originControlUnit">Origin control unit</param>
public RequestMovePatientActivities(string activity,
Entity[] origin,
DateTime time,
EntityPatient patient,
ControlUnit originControlUnit)
: base(activity, origin, time)
{
_patient = patient;
_originControlUnit = originControlUnit;
} // end of RequestMoveActivities
//--------------------------------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------------------------------
#region Constructor
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Parent control unit</param>
/// <param name="patient">Patient requiring service</param>
/// <param name="returnDelegate">Possible return delegate</param>
/// <param name="availability">Availabity delegate associated</param>
public EventBookingSpecialServiceDue(ControlUnit parentControlUnit,
EntityPatient patient,
RequestSpecialFacilitiyService returnDelegate,
DelegateAvailabilitiesForRequest availability)
: base(EventType.Standalone, parentControlUnit)
{
_patient = patient;
_returnDelegate = returnDelegate;
_availability = availability;
} // end of Event
} // end of PatientArrivalTime
#endregion
#region CreateEmergencyPath
/// <summary>
/// Method for patient path creation, uses core path method from base class
/// and casts action list for emergency department
/// </summary>
/// <param name="patient">Patient the path is created for</param>
/// <returns>Patient path</returns>
public EmergencyPatientPath CreateEmergencyPath(EntityPatient patient)
{
List <ActionTypeClass> actions;
Admission outpatientAdmission;
Admission inpatientAdmission;
GetCorePath(patient, null, out actions, out outpatientAdmission, out inpatientAdmission);
return(new EmergencyPatientPath(actions.Select(p => new EmergencyActionTypeClass(p)).ToList(), inpatientAdmission, outpatientAdmission, patient));
} // end of CreateEmergencyPath
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Parent special service control</param>
/// <param name="patient">Arriving patient</param>
/// <param name="originalRequest">Service request associated with arrival</param>
/// <param name="input">Special service input data</param>
public EventSpecialFacilityPatientArrival(ControlUnit parentControlUnit,
EntityPatient patient,
RequestSpecialFacilitiyService originalRequest,
IInputSpecialFacility input)
: base(EventType.Standalone, parentControlUnit)
{
_patient = patient;
_originalRequest = originalRequest;
_inputData = input;
} // end of Event
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Parent waiting list control unit</param>
/// <param name="patient">Waiting patient</param>
/// <param name="admissionType">Admission type for slot request</param>
/// <param name="earliestTime">Earliest possible slot time, e.g. follow up not before a week passed</param>
/// <param name="latestTime">Latest possible time for slot</param>
public ActivityOutpatientWaitingListWaitToAssignSlot(ControlUnit parentControlUnit,
EntityPatient patient,
Admission admissionType,
DateTime earliestTime,
DateTime latestTime)
: base(parentControlUnit, "ActivityOutpatientWaitingListWaitToAssignSlot", false)
{
_patient = patient;
_admissionType = admissionType;
_earliestTime = earliestTime;
} // end of Activity
} // end of CreateOutpatientTreatmentPath
#endregion
#region GetNextWaitingListPatient
/// <summary>
/// Stream of patients arriving at the waiting list , for this example exponential interarrival time
/// and patients arrive 24/7
/// </summary>
/// <param name="arrivalTime">Arrival time of next patient</param>
/// <param name="admission">Admission type of next patient</param>
/// <param name="parentControlUnit">Control unit of outpatient department</param>
/// <param name="currentTime">Current time</param>
/// <returns>Next patient with associated patient class</returns>
public EntityPatient GetNextWaitingListPatient(out DateTime arrivalTime, out Admission admission, ControlUnit parentControlUnit, DateTime currentTime)
{
PatientClass newPatientClass = (PatientClass)PatientClassPerXmlPatientClass[PatientClassDistribution.GetRandomValue()].Clone();
EntityPatient patient = new EntityPatient(EntityPatient.RunningPatientID++, newPatientClass);
admission = new Admission(patient, new OutpatientAdmissionTypes("SurgicalOutpatient"), 0, 100, true);
arrivalTime = currentTime + TimeSpan.FromMinutes(Distributions.Instance.Exponential(400));
return(patient);
} // end of GetNextWaitingListPatient
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="patient">Waiting patient</param>
/// <param name="time">Time request is filed</param>
/// <param name="admissionType">Admission type for slot request</param>
/// <param name="earliestTime">Earliest possible slot time, e.g. follow up not before a week passed</param>
/// <param name="latestTime">Latest possible time for slot</param>
public RequestOutpatientWaitingListPatientToAssignSlot(EntityPatient patient,
DateTime time,
Admission admissionType,
DateTime earliestTime,
DateTime latestTime)
: base("ActivityOutpatientWaitingListAssignPatientToSlot", patient.ToArray(), time)
{
_patient = patient;
_admissionType = admissionType;
_earliestTime = earliestTime;
_latestTime = latestTime;
} // end of RequestOutpatientTreatment
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="parentControlUnit">Parent waiting list conrol</param>
/// <param name="outpatientControlUnit">Parent outpatient department control</param>
/// <param name="patient">Arriving patient</param>
/// <param name="admissionType">Admission type of arriving patient</param>
/// <param name="input">Corresponding outpatient input data</param>
public EventOutpatientWaitingListPatientArrival(ControlUnit parentControlUnit,
ControlUnitOutpatient outpatientControlUnit,
EntityPatient patient,
Admission admissionType,
IInputOutpatient input)
: base(EventType.Standalone, parentControlUnit)
{
_patient = patient;
_admissionType = admissionType;
_outpatientControlUnit = outpatientControlUnit;
_inputData = input;
} // end of Event
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="patient">Patient requesting the service</param>
/// <param name="degreeOfCompletion">In case a activity was pre-empted</param>
/// <param name="actionType">The requested action type</param>
/// <param name="time">Time the request is filed</param>
/// <param name="resources">There maybe a pre-defined resource set for the activity, e.g. corresponding doctors</param>
/// <param name="slotTime">Original slot time</param>
/// <param name="isWalkIn">Flag if patient is a walk-in patient</param>
public RequestOutpatientAction(EntityPatient patient,
double degreeOfCompletion,
OutpatientActionTypeClass actionType,
DateTime time,
ResourceSet resources,
DateTime slotTime,
bool isWalkIn)
: base(patient, degreeOfCompletion, actionType, time, resources)
{
_slotTime = slotTime;
_isWalkIn = isWalkIn;
} // end of RequestEmergencyAssistedTreatment
} // end of PatientSpecialActionTime
#endregion
#region CreatePatientPath
/// <summary>
/// Method for patient path creation, uses core path method from base class
/// and casts action list for special service
/// </summary>
/// <param name="admission">Admission type for special service</param>
/// <param name="patient">Patient the path is created for</param>
/// <param name="orignalRequest">Request that is the basis for the patient being admitted to the special service control</param>
/// <returns>Patient path</returns>
public SpecialServicePatientPath CreatePatientPath(SpecialServiceAdmissionTypes admission,
EntityPatient patient,
RequestSpecialFacilitiyService orignalRequest)
{
List <ActionTypeClass> actions;
Admission outpatientAdmission;
Admission inpatientAdmission;
GetCorePath(patient, admission, out actions, out outpatientAdmission, out inpatientAdmission);
return(new SpecialServicePatientPath(actions.Select(p => new SpecialServiceActionTypeClass(p)).ToList(), orignalRequest, patient));
} // end of CreatePatientPath
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="parentControlUnit">Parent outpatient control</param>
/// <param name="patient">Arriving patient</param>
/// <param name="scheduledTime">Scheduled time of arrival</param>
/// <param name="inputData">Corresponding input data</param>
/// <param name="admission">Corresponding admission of arrival</param>
public EventOutpatientArrival(ControlUnit parentControlUnit,
EntityPatient patient,
DateTime scheduledTime,
IInputOutpatient inputData,
Admission admission)
: base(EventType.Standalone, parentControlUnit)
{
_scheduledTime = scheduledTime;
_patient = patient;
_inputData = inputData;
_admission = admission;
} // end of Event
