} // end of HandleAvailabilitiesSpecialServiceRequest
#endregion
#region HandleRequireDocs
/// <summary>
/// Handles a request to send doctors for consultation or assisting between departments
/// </summary>
/// <param name="del">The original request for doctors to consult or assist</param>
/// <param name="controlUnit">Control unit that filed request for assistance or consultation</param>
/// <param name="time">Time request was filed</param>
/// <param name="simEngine">SimEngine responsible for simulation execution</param>
/// <returns>True if request has been handled</returns>
static public bool HandleRequireDocs(IDelegate del, ControlUnit controlUnit, DateTime time, ISimulationEngine simEngine)
{
foreach (SkillSet reqSkill in ((DelegateRequestDocsForAssisting)del).RequiredSkillSets)
{
List <EntityDoctor> possibleDoc = ((ControlUnitHealthCare)controlUnit).FindDoctorWithSkillSet(reqSkill);
if (possibleDoc.Count == 0)
{
break;
}
EntityDoctor chosenDoc = null;
foreach (EntityDoctor doc in possibleDoc)
{
if (doc.ParentControlUnit == controlUnit)
{
ActivityMove possibleMove = doc.GetPossibleMovingActivity();
if (possibleMove != null &&
(possibleMove.Destination == del.OriginControlUnit ||
possibleMove.Destination == doc.BaseControlUnit))
{
chosenDoc = doc;
break;
} // end if
} // end if
if (((ControlUnitHealthCare)doc.ParentControlUnit).ControlUnitType == Enums.ControlUnitType.Inpatient)
{
chosenDoc = doc;
break;
} // end if
} // end foreach
if (chosenDoc == null)
{
chosenDoc = possibleDoc.First();
}
if (chosenDoc.ParentControlUnit == controlUnit)
{
ActivityMove possibleMove = chosenDoc.GetPossibleMovingActivity();
if (possibleMove != null && possibleMove.Destination == chosenDoc.BaseControlUnit)
{
simEngine.RemoveScheduledEvent(possibleMove.EndEvent);
chosenDoc.StopCurrentActivities(time, simEngine);
ActivityMove move = new ActivityMove(controlUnit, chosenDoc, controlUnit, del.OriginControlUnit, del, TimeSpan.FromMinutes(1));
move.StartEvent.Trigger(time, simEngine);
} // end if
}
else
{
controlUnit.SendDelegateTo(chosenDoc.ParentControlUnit, new DelegateSentDocForAssistedTreatment((ControlUnitHealthCare)del.OriginControlUnit, reqSkill));
} // end if
} // end foreach
return(true);
} // end of HandleRequireDocs
//
public static ActivityInterface createActivity(eActivity activity, AvatorCharacter _refAvatar)
{
ActivityInterface action = null;
switch( activity ){
case eActivity.Think: action = new ActivityThink(); break;
case eActivity.Move: action = new ActivityMove(); break;
case eActivity.Conversation: action = new ActivityConversation(); break;
case eActivity.Working: action = new ActivityWork(); break;
default: break;
}
if( action != null ){
action.refAvatar = _refAvatar;
}
return action;
}
} // 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
} // end of OriginalRequest
#endregion
#region TakeNextAction
/// <summary>
/// Action taking along path. Different actions for return and
/// actions within the special service department
/// </summary>
/// <param name="simEngine">SimEngine responsible for simulation execution</param>
/// <param name="currentEvent">Event after which next action is taken</param>
/// <param name="time">Time next action is taken</param>
/// <param name="parentControlUnit">Control unit that hosts the next action</param>
/// <returns>Returns true if Patient goes in an waiting activitiy before next action, else false </returns>
public override bool TakeNextAction(
ISimulationEngine simEngine,
Event currentEvent,
DateTime time,
ControlUnit parentControlUnit)
{
ControlUnit parentDepartmentControl = parentControlUnit;
if (parentControlUnit is ControlUnitOrganizationalUnit)
{
parentDepartmentControl = ((ControlUnitOrganizationalUnit)parentControlUnit).ParentDepartmentControl;
}
if (GetCurrentActionType().Type == "Return")
{
ControlUnitManagement jointControl = (ControlUnitManagement)parentControlUnit.FindSmallestJointControl(OriginalRequest.OriginControlUnit);
ActivityMove movePatientBack = new ActivityMove(parentControlUnit,
ParentPatient,
parentDepartmentControl,
OriginalRequest.OriginControlUnit,
OriginalRequest,
jointControl.InputData.DurationMove(ParentPatient,
parentControlUnit,
OriginalRequest.OriginControlUnit));
movePatientBack.StartEvent.Trigger(time, simEngine);
return(false);
} // end if
SpecialServiceActionTypeClass currentType = GetCurrentActionType();
RequestSpecialFacilityAction req =
new RequestSpecialFacilityAction(ParentPatient, 0, currentType, time, new ResourceSet());
parentControlUnit.AddRequest(req);
return(true);
} // end if TakeNextAction
} // end of PerformDisptatching
#endregion
#region PerformControlled
/// <summary>
/// Sends assisting staff members that are not further required back to their origin
/// control unit
/// </summary>
/// <param name="startTime">Time rules are executed</param>
/// <param name="simEngine">SimEngine responsible for simulation execution</param>
/// <returns>False</returns>
protected bool PerformControlled(DateTime time, ISimulationEngine simEngine)
{
IEnumerable <EntityDoctor> assistingDocs = HandledDoctors.Where(p => p.BaseControlUnit != this);
IEnumerable <RequestOutpatientAction> assistedRequests = RAEL.Where(p => p.GetType() == typeof(RequestOutpatientAction) && ((RequestOutpatientAction)p).IsAssistedDoctor).Cast <RequestOutpatientAction>().ToList();
bool moveTriggered = false;
foreach (EntityDoctor doc in assistingDocs)
{
bool skillRequired = false;
if (doc.IsWaiting())
{
foreach (RequestOutpatientAction req in assistedRequests)
{
foreach (SkillSet skillSet in req.ActionType.AssistingDoctorRequirements)
{
if (doc.SatisfiesSkillSet(skillSet))
{
skillRequired = true;
}
} // end foreach
} // end foreach
if (!skillRequired)
{
ControlUnitManagement jointControl = (ControlUnitManagement)FindSmallestJointControl(doc.BaseControlUnit);
ActivityMove moveBack = new ActivityMove(jointControl, doc, this, doc.BaseControlUnit, null, jointControl.InputData.DurationMove(doc, this, doc.BaseControlUnit));
doc.StopCurrentActivities(time, simEngine);
moveBack.StartEvent.Trigger(time, simEngine);
moveTriggered = true;
} // end if
} // end if
} // end foreach
return(moveTriggered);
return(false);
} // end of PerformControlled
} // end of
#endregion
#region HandleImmediateSpecialServiceRequest
/// <summary>
/// Standard method to handle a "immediate" booking of a special service control.
/// Sends the patient on a move from the requesting control to the special service control.
/// </summary>
/// <param name="del">The availability delegate</param>
/// <param name="controlUnit">The control unit that filed the original request</param>
/// <param name="time">Time the request is filed</param>
/// <param name="simEngine">SimEngine responsible for simulation execution</param>
/// <returns>True if request has been handled</returns>
public static bool HandleImmediateSpecialServiceRequest(IDelegate del, ControlUnit controlUnit, DateTime time, ISimulationEngine simEngine)
{
#region ServiceRequests
DelegateAvailabilitiesForRequest availability = (DelegateAvailabilitiesForRequest)del;
if (availability.BookingType != SpecialServiceBookingTypes.Immediate)
{
throw new InvalidOperationException("Only immediate bookings handled");
}
if (availability.OriginalServiceRequest is RequestSpecialFacilitiyService)
{
RequestSpecialFacilitiyService req = (RequestSpecialFacilitiyService)availability.OriginalServiceRequest;
ControlUnitManagement jointControl = (ControlUnitManagement)controlUnit.ParentControlUnit.FindSmallestJointControl(availability.ServiceControl);
ActivityMove movePatientToSpecialTreatment
= new ActivityMove(jointControl,
req.Patient,
controlUnit,
availability.ServiceControl,
req,
jointControl.InputData.DurationMove(req.Patient,
controlUnit,
availability.ServiceControl));
req.Patient.StopWaitingActivity(time, simEngine);
movePatientToSpecialTreatment.StartEvent.Trigger(time, simEngine);
return(true);
} // end if
#endregion
return(false);
} // end of HandleAvailabilitiesSpecialServiceRequest
