public Constraints8ConstraintElement(
Id2IndexElement d2IndexElement,
IrIndexElement rIndexElement,
IsIndexElement sIndexElement,
ItIndexElement tIndexElement,
Id1 d1,
It t,
Ix x,
IxHat xHat,
Iα α)
{
Expression LHS = xHat.Value[
sIndexElement,
rIndexElement,
t.GetElementAt(
tIndexElement.Key + d2IndexElement.Value.Value.Value)];
Expression RHS = Expression.Sum(
d1.Value
.Select(
y => x.GetElementAtAsint(
sIndexElement,
rIndexElement,
t.GetElementAt(
tIndexElement.Key + y.Value.Value.Value))
*
α.Value[rIndexElement, y, d2IndexElement]));
this.Value = LHS == RHS;
}
public IScenarioUtilizedTimesResultElement Calculate(
IScenarioUtilizedTimesResultElementFactory scenarioUtilizedTimesResultElementFactory,
IΛIndexElement ΛIndexElement,
Isrt srt,
Ih h,
In n,
IxHat xHat)
{
return(scenarioUtilizedTimesResultElementFactory.Create(
ΛIndexElement,
srt.Value.Select(w =>
xHat.GetElementAtAsint(
w.sIndexElement,
w.rIndexElement,
w.tIndexElement)
*
n.GetElementAtAsint(
w.sIndexElement,
ΛIndexElement)
*
h.GetElementAtAsdecimal(
w.sIndexElement,
ΛIndexElement))
.Sum()));
}
public IConstraints1ConstraintElement Create(
IsIndexElement sIndexElement,
ItIndexElement tIndexElement,
Ir r,
IxHat xHat,
Iz z)
{
IConstraints1ConstraintElement constraintElement = null;
try
{
constraintElement = new Constraints1ConstraintElement(
sIndexElement,
tIndexElement,
r,
xHat,
z);
}
catch (Exception exception)
{
this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
}
return(constraintElement);
}
public IConstraints9ConstraintElement Create(
IrIndexElement rIndexElement,
IsIndexElement sIndexElement,
ItIndexElement tIndexElement,
Ix x,
IxHat xHat)
{
IConstraints9ConstraintElement constraintElement = null;
try
{
constraintElement = new Constraints9ConstraintElement(
rIndexElement,
sIndexElement,
tIndexElement,
x,
xHat);
}
catch (Exception exception)
{
this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
}
return(constraintElement);
}
public ISurgicalSpecialtyNumberAssignedOperatingRoomsResultElement Calculate(
ISurgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory surgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory,
IΔParameterElement ΔParameterElement,
IxHat xHat)
{
return(surgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory.Create(
ΔParameterElement.jIndexElement,
ΔParameterElement.Value.SelectMany(a => xHat.Value.Where(i => i.sIndexElement == a && i.Value).Select(w => w.rIndexElement)).Distinct().Count()));
}
public ISurgicalSpecialtyNumberAssignedWeekdaysResultElement Calculate(
ISurgicalSpecialtyNumberAssignedWeekdaysResultElementFactory surgicalSpecialtyNumberAssignedWeekdaysResultElementFactory,
IΔParameterElement ΔParameterElement,
IxHat xHat)
{
return(surgicalSpecialtyNumberAssignedWeekdaysResultElementFactory.Create(
ΔParameterElement.jIndexElement,
ΔParameterElement.Value.SelectMany(a => xHat.Value.Where(i => i.sIndexElement == a && i.Value).Select(i => i.tIndexElement.Value.ToDateTimeOffset(TimeSpan.Zero).UtcDateTime.DayOfWeek)).Distinct().Count()));
}
public ISurgeonNumberAssignedWeekdaysResultElement Calculate(
ISurgeonNumberAssignedWeekdaysResultElementFactory surgeonNumberAssignedWeekdaysResultElementFactory,
IsIndexElement sIndexElement,
IxHat xHat)
{
return(surgeonNumberAssignedWeekdaysResultElementFactory.Create(
sIndexElement,
xHat.Value.Where(i => i.sIndexElement == sIndexElement && i.Value).Select(i => i.tIndexElement.Value.ToDateTimeOffset(TimeSpan.Zero).UtcDateTime.DayOfWeek).Distinct().Count()));
}
public Constraints3ConstraintElement(
IrIndexElement rIndexElement,
IsIndexElement sIndexElement,
ItIndexElement tIndexElement,
Iy y,
IxHat xHat)
{
Expression LHS = xHat.Value[sIndexElement, rIndexElement, tIndexElement];
int RHS = y.GetElementAtAsint(
sIndexElement,
rIndexElement);
this.Value = LHS <= RHS;
}
public ISurgicalSpecialtyNumberAssignedWeekdays Calculate(
ISurgicalSpecialtyNumberAssignedWeekdaysResultElementFactory surgicalSpecialtyNumberAssignedWeekdaysResultElementFactory,
ISurgicalSpecialtyNumberAssignedWeekdaysFactory surgicalSpecialtyNumberAssignedWeekdaysFactory,
ISurgicalSpecialtyNumberAssignedWeekdaysResultElementCalculation surgicalSpecialtyNumberAssignedWeekdaysResultElementCalculation,
IΔ Δ,
IxHat xHat)
{
return(surgicalSpecialtyNumberAssignedWeekdaysFactory.Create(
Δ.Value
.Select(i => surgicalSpecialtyNumberAssignedWeekdaysResultElementCalculation.Calculate(
surgicalSpecialtyNumberAssignedWeekdaysResultElementFactory,
i,
xHat))
.ToImmutableList()));
}
public ISurgeonNumberAssignedWeekdays Calculate(
ISurgeonNumberAssignedWeekdaysResultElementFactory surgeonNumberAssignedWeekdaysResultElementFactory,
ISurgeonNumberAssignedWeekdaysFactory surgeonNumberAssignedWeekdaysFactory,
ISurgeonNumberAssignedWeekdaysResultElementCalculation surgeonNumberAssignedWeekdaysResultElementCalculation,
Is s,
IxHat xHat)
{
return(surgeonNumberAssignedWeekdaysFactory.Create(
s.Value
.Select(w => surgeonNumberAssignedWeekdaysResultElementCalculation.Calculate(
surgeonNumberAssignedWeekdaysResultElementFactory,
w,
xHat))
.ToImmutableList()));
}
public Constraints1ConstraintElement(
IsIndexElement sIndexElement,
ItIndexElement tIndexElement,
Ir r,
IxHat xHat,
Iz z)
{
Expression LHS = Expression.Sum(
r.Value
.Select(
y => xHat.Value[sIndexElement, y, tIndexElement]));
Expression RHS = z.Value[sIndexElement, tIndexElement];
this.Value = LHS == RHS;
}
public IxHat Create(
VariableCollection <IsIndexElement, IrIndexElement, ItIndexElement> value)
{
IxHat variable = null;
try
{
variable = new xHat(
value);
}
catch (Exception exception)
{
this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
}
return(variable);
}
public Constraints2ConstraintElement(
IrIndexElement rIndexElement,
ItIndexElement tIndexElement,
Is s,
Iγ γ,
IxHat xHat)
{
Expression LHS = Expression.Sum(
s.Value
.Select(
y => xHat.Value[y, rIndexElement, tIndexElement]));
int RHS = γ.GetElementAtAsint(
rIndexElement,
tIndexElement);
this.Value = LHS <= RHS;
}
public IScenarioTotalTimesResultElement Calculate(
IScenarioTotalTimesResultElementFactory scenarioTotalTimesResultElementFactory,
IΛIndexElement ΛIndexElement,
Isrt srt,
IH H,
IxHat xHat)
{
return(scenarioTotalTimesResultElementFactory.Create(
ΛIndexElement,
srt.Value.Select(w =>
xHat.GetElementAtAsint(
w.sIndexElement,
w.rIndexElement,
w.tIndexElement)
*
H.Value.Value.Value)
.Sum()));
}
public IScenarioTotalTimes Calculate(
IScenarioTotalTimesResultElementFactory scenarioTotalTimesResultElementFactory,
IScenarioTotalTimesFactory scenarioTotalTimesFactory,
IScenarioTotalTimesResultElementCalculation scenarioTotalTimesResultElementCalculation,
IΛ Λ,
Isrt srt,
IH H,
IxHat xHat)
{
return(scenarioTotalTimesFactory.Create(
Λ.Value
.Select(w => scenarioTotalTimesResultElementCalculation.Calculate(
scenarioTotalTimesResultElementFactory,
w,
srt,
H,
xHat))
.ToImmutableList()));
}
public ISurgeonScenarioNumberPatients Calculate(
ISurgeonScenarioNumberPatientsResultElementFactory surgeonScenarioNumberPatientsResultElementFactory,
ISurgeonScenarioNumberPatientsFactory surgeonScenarioNumberPatientsFactory,
ISurgeonScenarioNumberPatientsResultElementCalculation surgeonScenarioNumberPatientsResultElementCalculation,
Irt rt,
IsΛ sΛ,
In n,
IxHat xHat)
{
return(surgeonScenarioNumberPatientsFactory.Create(
sΛ.Value
.Select(w => surgeonScenarioNumberPatientsResultElementCalculation.Calculate(
surgeonScenarioNumberPatientsResultElementFactory,
w.sIndexElement,
w.ΛIndexElement,
rt,
n,
xHat))
.ToImmutableList()));
}
public ISurgeonScenarioNumberPatientsResultElement Calculate(
ISurgeonScenarioNumberPatientsResultElementFactory surgeonScenarioNumberPatientsResultElementFactory,
IsIndexElement sIndexElement,
IΛIndexElement ΛIndexElement,
Irt rt,
In n,
IxHat xHat)
{
return(surgeonScenarioNumberPatientsResultElementFactory.Create(
sIndexElement,
ΛIndexElement,
rt.Value
.Select(a =>
xHat.GetElementAtAsint(
sIndexElement,
a.rIndexElement,
a.tIndexElement)
*
n.GetElementAtAsint(
sIndexElement,
ΛIndexElement))
.Sum()));
}
public HM5OutputContext(
ICalculationsAbstractFactory calculationsAbstractFactory,
IDependenciesAbstractFactory dependenciesAbstractFactory,
IResultElementsAbstractFactory resultElementsAbstractFactory,
IResultsAbstractFactory resultsAbstractFactory,
IHM5Model HM5Model,
Solution solution)
{
// BestBound
this.BestBound = resultsAbstractFactory.CreateBestBoundFactory().Create(
(decimal)solution.BestBound)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// Gap
this.Gap = resultsAbstractFactory.CreateGapFactory().Create(
(decimal)solution.Gap)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// NumberOfExploredNodes
this.NumberOfExploredNodes = resultsAbstractFactory.CreateNumberOfExploredNodesFactory().Create(
solution.NumberOfExploredNodes)
.GetValueForOutputContext();
// ObjectiveValue
this.ObjectiveValue = resultsAbstractFactory.CreateObjectiveValueFactory().Create(
(decimal)solution.ObjectiveValues.SingleOrDefault().Value)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// OverallWallTime
this.OverallWallTime = resultsAbstractFactory.CreateOverallWallTimeFactory().Create(
solution.OverallWallTime)
.GetValueForOutputContext();
// IHat(t, Λ)
this.DayScenarioRecoveryWardCensuses = HM5Model.IHat.GetElementsAt(
resultElementsAbstractFactory.CreateIHatResultElementFactory(),
resultsAbstractFactory.CreateIHatFactory(),
HM5Model.tΛ)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// xHat(s, r, t)
IxHat xHat = HM5Model.xHat.GetElementsAt(
resultElementsAbstractFactory.CreatexHatResultElementFactory(),
resultsAbstractFactory.CreatexHatFactory(),
HM5Model.srt);
this.SurgeonOperatingRoomDayAssignments = xHat
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// SurgeonNumberAssignedOperatingRooms
this.SurgeonNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
resultElementsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementFactory(),
resultsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsFactory(),
calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
HM5Model.s,
xHat)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// SurgeonNumberAssignedWeekdays
this.SurgeonNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
resultElementsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementFactory(),
resultsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysFactory(),
calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
HM5Model.s,
xHat)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// SurgeonScenarioNumberPatients
ISurgeonScenarioNumberPatients surgeonScenarioNumberPatients = calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsCalculationFactory().Create().Calculate(
resultElementsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementFactory(),
resultsAbstractFactory.CreateSurgeonScenarioNumberPatientsFactory(),
calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementCalculationFactory().Create(),
HM5Model.rt,
HM5Model.sΛ,
HM5Model.n,
xHat);
this.SurgeonScenarioNumberPatients = surgeonScenarioNumberPatients.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ScenarioNumberPatients(Λ)
this.ScenarioNumberPatients = calculationsAbstractFactory.CreateScenarioNumberPatientsCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateScenarioNumberPatientsResultElementFactory(),
resultsAbstractFactory.CreateScenarioNumberPatientsFactory(),
calculationsAbstractFactory.CreateScenarioNumberPatientsResultElementCalculationFactory().Create(),
HM5Model.Λ,
surgeonScenarioNumberPatients)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// SurgicalSpecialtyNumberAssignedOperatingRooms
this.SurgicalSpecialtyNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory(),
resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsFactory(),
calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
HM5Model.Δ,
xHat)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// SurgicalSpecialtyNumberAssignedWeekdays
this.SurgicalSpecialtyNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementFactory(),
resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysFactory(),
calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
HM5Model.Δ,
xHat)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// z(s, t)
Interfaces.Results.SurgeonDayAssignments.Iz z = HM5Model.z.GetElementsAt(
resultElementsAbstractFactory.CreatezResultElementFactory(),
resultsAbstractFactory.CreatezFactory(),
HM5Model.st);
this.SurgeonDayAssignments = z
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ExpectedValueΦ(s, l, Λ)
Interfaces.Results.SurgeonDayScenarioCumulativeNumberPatients.IExpectedValueΦ expectedValueΦ = calculationsAbstractFactory.CreateExpectedValueΦCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateExpectedValueΦResultElementFactory(),
resultsAbstractFactory.CreateExpectedValueΦFactory(),
calculationsAbstractFactory.CreateExpectedValueΦResultElementCalculationFactory().Create(),
HM5Model.l,
HM5Model.t,
HM5Model.slΛ,
HM5Model.L,
HM5Model.p,
HM5Model.μ);
// VarianceΦ(s, l, Λ)
Interfaces.Results.SurgeonDayScenarioCumulativeNumberPatients.IVarianceΦ varianceΦ = calculationsAbstractFactory.CreateVarianceΦCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateVarianceΦResultElementFactory(),
resultsAbstractFactory.CreateVarianceΦFactory(),
calculationsAbstractFactory.CreateVarianceΦResultElementCalculationFactory().Create(),
HM5Model.l,
HM5Model.t,
HM5Model.slΛ,
HM5Model.L,
HM5Model.p,
HM5Model.μ,
HM5Model.σ);
// ExpectedValueI(t, Λ)
Interfaces.Results.DayScenarioRecoveryWardUtilizations.IExpectedValueI expectedValueI = calculationsAbstractFactory.CreateExpectedValueICalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateExpectedValueIResultElementFactory(),
resultsAbstractFactory.CreateExpectedValueIFactory(),
calculationsAbstractFactory.CreateExpectedValueIResultElementCalculationFactory().Create(),
HM5Model.l,
HM5Model.t,
HM5Model.st,
HM5Model.tΛ,
expectedValueΦ,
z);
this.DayScenarioRecoveryWardUtilizationExpectedValues = expectedValueI
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// VarianceI(t, Λ)
Interfaces.Results.DayScenarioRecoveryWardUtilizations.IVarianceI varianceI = calculationsAbstractFactory.CreateVarianceICalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateVarianceIResultElementFactory(),
resultsAbstractFactory.CreateVarianceIFactory(),
calculationsAbstractFactory.CreateVarianceIResultElementCalculationFactory().Create(),
HM5Model.l,
HM5Model.t,
HM5Model.st,
HM5Model.tΛ,
varianceΦ,
z);
this.DayScenarioRecoveryWardUtilizationVariances = varianceI
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// EBS(t, Λ)
Interfaces.Results.DayScenarioExpectedBedShortages.IEBS EBS = calculationsAbstractFactory.CreateEBSCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateEBSResultElementFactory(),
resultsAbstractFactory.CreateEBSFactory(),
calculationsAbstractFactory.CreateEBSResultElementCalculationFactory().Create(),
HM5Model.tΛ,
HM5Model.Ω,
expectedValueI,
varianceI);
this.DayScenarioExpectedBedShortages = EBS
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// TEBS(Λ)
Interfaces.Results.ScenarioTotalExpectedBedShortages.ITEBS TEBS_Λ = calculationsAbstractFactory.CreateTEBSΛCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateTEBSΛResultElementFactory(),
resultsAbstractFactory.CreateTEBSΛFactory(),
calculationsAbstractFactory.CreateTEBSΛResultElementCalculationFactory().Create(),
HM5Model.t,
HM5Model.Λ,
EBS);
this.ScenarioTotalExpectedBedShortages = TEBS_Λ
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// TEBS
this.TotalExpectedBedShortage = calculationsAbstractFactory.CreateTEBSCalculationFactory().Create()
.Calculate(
resultsAbstractFactory.CreateTEBSFactory(),
HM5Model.Λ,
HM5Model.Ρ,
TEBS_Λ)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ScenarioTotalTimes(Λ)
IScenarioTotalTimes scenarioTotalTimes = calculationsAbstractFactory.CreateScenarioTotalTimesCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateScenarioTotalTimesResultElementFactory(),
resultsAbstractFactory.CreateScenarioTotalTimesFactory(),
calculationsAbstractFactory.CreateScenarioTotalTimesResultElementCalculationFactory().Create(),
HM5Model.Λ,
HM5Model.srt,
HM5Model.H,
xHat);
this.ScenarioTotalTimes = scenarioTotalTimes.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ScenarioUtilizedTimes(Λ)
IScenarioUtilizedTimes scenarioUtilizedTimes = calculationsAbstractFactory.CreateScenarioUtilizedTimesCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateScenarioUtilizedTimesResultElementFactory(),
resultsAbstractFactory.CreateScenarioUtilizedTimesFactory(),
calculationsAbstractFactory.CreateScenarioUtilizedTimesResultElementCalculationFactory().Create(),
HM5Model.Λ,
HM5Model.srt,
HM5Model.h,
HM5Model.n,
xHat);
this.ScenarioUtilizedTimes = scenarioUtilizedTimes.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ScenarioUnutilizedTimes(Λ)
IScenarioUnutilizedTimes scenarioUnutilizedTimes = calculationsAbstractFactory.CreateScenarioUnutilizedTimesCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateScenarioUnutilizedTimesResultElementFactory(),
resultsAbstractFactory.CreateScenarioUnutilizedTimesFactory(),
calculationsAbstractFactory.CreateScenarioUnutilizedTimesResultElementCalculationFactory().Create(),
HM5Model.Λ,
scenarioTotalTimes,
scenarioUtilizedTimes);
this.ScenarioUnutilizedTimes = scenarioUnutilizedTimes.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
// ScenarioUnderutilizations(Λ)
this.ScenarioUnderutilizations = calculationsAbstractFactory.CreateScenarioUnderutilizationsCalculationFactory().Create()
.Calculate(
resultElementsAbstractFactory.CreateScenarioUnderutilizationsResultElementFactory(),
resultsAbstractFactory.CreateScenarioUnderutilizationsFactory(),
calculationsAbstractFactory.CreateScenarioUnderutilizationsResultElementCalculationFactory().Create(),
HM5Model.Λ,
scenarioTotalTimes,
scenarioUnutilizedTimes)
.GetValueForOutputContext(
dependenciesAbstractFactory.CreateNullableValueFactory());
}
