public IScenarioNumberPatientsResultElement Calculate(
     IScenarioNumberPatientsResultElementFactory scenarioNumberPatientsResultElementFactory,
     IΛIndexElement ΛIndexElement,
     ISurgeonScenarioNumberPatients surgeonScenarioNumberPatients)
 {
     return(scenarioNumberPatientsResultElementFactory.Create(
                ΛIndexElement,
                surgeonScenarioNumberPatients.Value
                .Where(w => w.ΛIndexElement == ΛIndexElement)
                .Select(w => w.Value)
                .Sum()));
 }
 public IScenarioNumberPatients Calculate(
     IScenarioNumberPatientsResultElementFactory scenarioNumberPatientsResultElementFactory,
     IScenarioNumberPatientsFactory scenarioNumberPatientsFactory,
     IScenarioNumberPatientsResultElementCalculation scenarioNumberPatientsResultElementCalculation,
     IΛ Λ,
     ISurgeonScenarioNumberPatients surgeonScenarioNumberPatients)
 {
     return(scenarioNumberPatientsFactory.Create(
                Λ.Value
                .Select(i => scenarioNumberPatientsResultElementCalculation.Calculate(
                            scenarioNumberPatientsResultElementFactory,
                            i,
                            surgeonScenarioNumberPatients))
                .ToImmutableList()));
 }
Beispiel #3
0
        public ISurgeonScenarioNumberPatients Create(
            ImmutableList <ISurgeonScenarioNumberPatientsResultElement> value)
        {
            ISurgeonScenarioNumberPatients result = null;

            try
            {
                result = new SurgeonScenarioNumberPatients(
                    value);
            }
            catch (Exception exception)
            {
                this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
            }

            return(result);
        }
Beispiel #4
0
        public ISurgeonScenarioNumberPatients Create(
            ImmutableList <ISurgeonScenarioNumberPatientsResultElement> value)
        {
            ISurgeonScenarioNumberPatients result = null;

            try
            {
                result = new SurgeonScenarioNumberPatients(
                    value);
            }
            catch (Exception exception)
            {
                this.Log.Error(
                    exception.Message,
                    exception);
            }

            return(result);
        }
Beispiel #5
0
        public HM4OutputContext(
            ICalculationsAbstractFactory calculationsAbstractFactory,
            IDependenciesAbstractFactory dependenciesAbstractFactory,
            IResultElementsAbstractFactory resultElementsAbstractFactory,
            IResultsAbstractFactory resultsAbstractFactory,
            IHM4Model HM4Model,
            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 = HM4Model.IHat.GetElementsAt(
                resultElementsAbstractFactory.CreateIHatResultElementFactory(),
                resultsAbstractFactory.CreateIHatFactory(),
                HM4Model.tΛ)
                                                   .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // x(s, r, t)
            Ix x = HM4Model.x.GetElementsAt(
                resultElementsAbstractFactory.CreatexResultElementFactory(),
                resultsAbstractFactory.CreatexFactory(),
                HM4Model.srt);

            this.SurgeonOperatingRoomDayAssignments = x
                                                      .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonNumberAssignedOperatingRooms
            this.SurgeonNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsFactory(),
                calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
                HM4Model.s,
                x)
                                                       .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonNumberAssignedWeekdays
            this.SurgeonNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysFactory(),
                calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
                HM4Model.s,
                x)
                                                 .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonScenarioNumberPatients
            ISurgeonScenarioNumberPatients surgeonScenarioNumberPatients = calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonScenarioNumberPatientsFactory(),
                calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementCalculationFactory().Create(),
                HM4Model.rt,
                HM4Model.sΛ,
                HM4Model.n,
                x);

            this.SurgeonScenarioNumberPatients = surgeonScenarioNumberPatients.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioNumberPatients(Λ)
            this.ScenarioNumberPatients = calculationsAbstractFactory.CreateScenarioNumberPatientsCalculationFactory().Create()
                                          .Calculate(
                resultElementsAbstractFactory.CreateScenarioNumberPatientsResultElementFactory(),
                resultsAbstractFactory.CreateScenarioNumberPatientsFactory(),
                calculationsAbstractFactory.CreateScenarioNumberPatientsResultElementCalculationFactory().Create(),
                HM4Model.Λ,
                surgeonScenarioNumberPatients)
                                          .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgicalSpecialtyNumberAssignedOperatingRooms
            this.SurgicalSpecialtyNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory(),
                resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsFactory(),
                calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
                HM4Model.Δ,
                x)
                                                                 .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgicalSpecialtyNumberAssignedWeekdays
            this.SurgicalSpecialtyNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementFactory(),
                resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysFactory(),
                calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
                HM4Model.Δ,
                x)
                                                           .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // z(s, t)
            Interfaces.Results.SurgeonDayAssignments.Iz z = HM4Model.z.GetElementsAt(
                resultElementsAbstractFactory.CreatezResultElementFactory(),
                resultsAbstractFactory.CreatezFactory(),
                HM4Model.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(),
                HM4Model.l,
                HM4Model.t,
                HM4Model.slΛ,
                HM4Model.L,
                HM4Model.p,
                HM4Model.μ);

            // VarianceΦ(s, l, Λ)
            Interfaces.Results.SurgeonDayScenarioCumulativeNumberPatients.IVarianceΦ varianceΦ = calculationsAbstractFactory.CreateVarianceΦCalculationFactory().Create()
                                                                                                 .Calculate(
                resultElementsAbstractFactory.CreateVarianceΦResultElementFactory(),
                resultsAbstractFactory.CreateVarianceΦFactory(),
                calculationsAbstractFactory.CreateVarianceΦResultElementCalculationFactory().Create(),
                HM4Model.l,
                HM4Model.t,
                HM4Model.slΛ,
                HM4Model.L,
                HM4Model.p,
                HM4Model.μ,
                HM4Model.σ);

            // ExpectedValueI(t, Λ)
            Interfaces.Results.DayScenarioRecoveryWardUtilizations.IExpectedValueI expectedValueI = calculationsAbstractFactory.CreateExpectedValueICalculationFactory().Create()
                                                                                                    .Calculate(
                resultElementsAbstractFactory.CreateExpectedValueIResultElementFactory(),
                resultsAbstractFactory.CreateExpectedValueIFactory(),
                calculationsAbstractFactory.CreateExpectedValueIResultElementCalculationFactory().Create(),
                HM4Model.l,
                HM4Model.t,
                HM4Model.st,
                HM4Model.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(),
                HM4Model.l,
                HM4Model.t,
                HM4Model.st,
                HM4Model.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(),
                HM4Model.tΛ,
                HM4Model.Ω,
                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(),
                HM4Model.t,
                HM4Model.Λ,
                EBS);

            this.ScenarioTotalExpectedBedShortages = TEBS_Λ
                                                     .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // TEBS
            this.TotalExpectedBedShortage = calculationsAbstractFactory.CreateTEBSCalculationFactory().Create()
                                            .Calculate(
                resultsAbstractFactory.CreateTEBSFactory(),
                HM4Model.Λ,
                HM4Model.Ρ,
                TEBS_Λ)
                                            .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioTotalTimes(Λ)
            IScenarioTotalTimes scenarioTotalTimes = calculationsAbstractFactory.CreateScenarioTotalTimesCalculationFactory().Create()
                                                     .Calculate(
                resultElementsAbstractFactory.CreateScenarioTotalTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioTotalTimesFactory(),
                calculationsAbstractFactory.CreateScenarioTotalTimesResultElementCalculationFactory().Create(),
                HM4Model.Λ,
                HM4Model.srt,
                HM4Model.H,
                x);

            this.ScenarioTotalTimes = scenarioTotalTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUtilizedTimes(Λ)
            IScenarioUtilizedTimes scenarioUtilizedTimes = calculationsAbstractFactory.CreateScenarioUtilizedTimesCalculationFactory().Create()
                                                           .Calculate(
                resultElementsAbstractFactory.CreateScenarioUtilizedTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUtilizedTimesFactory(),
                calculationsAbstractFactory.CreateScenarioUtilizedTimesResultElementCalculationFactory().Create(),
                HM4Model.Λ,
                HM4Model.srt,
                HM4Model.h,
                HM4Model.n,
                x);

            this.ScenarioUtilizedTimes = scenarioUtilizedTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUnutilizedTimes(Λ)
            IScenarioUnutilizedTimes scenarioUnutilizedTimes = calculationsAbstractFactory.CreateScenarioUnutilizedTimesCalculationFactory().Create()
                                                               .Calculate(
                resultElementsAbstractFactory.CreateScenarioUnutilizedTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUnutilizedTimesFactory(),
                calculationsAbstractFactory.CreateScenarioUnutilizedTimesResultElementCalculationFactory().Create(),
                HM4Model.Λ,
                scenarioTotalTimes,
                scenarioUtilizedTimes);

            this.ScenarioUnutilizedTimes = scenarioUnutilizedTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUnderutilizations(Λ)
            this.ScenarioUnderutilizations = calculationsAbstractFactory.CreateScenarioUnderutilizationsCalculationFactory().Create()
                                             .Calculate(
                resultElementsAbstractFactory.CreateScenarioUnderutilizationsResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUnderutilizationsFactory(),
                calculationsAbstractFactory.CreateScenarioUnderutilizationsResultElementCalculationFactory().Create(),
                HM4Model.Λ,
                scenarioTotalTimes,
                scenarioUnutilizedTimes)
                                             .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());
        }
        public HM3BOutputContext(
            ICalculationsAbstractFactory calculationsAbstractFactory,
            IDependenciesAbstractFactory dependenciesAbstractFactory,
            IResultElementsAbstractFactory resultElementsAbstractFactory,
            IResultsAbstractFactory resultsAbstractFactory,
            IHM3BModel HM3BModel,
            Solution solution,
            HM3BEncodingEnum HM3BEncodingEnum)
        {
            // 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();

            // x(s, r, t)
            Ix x = HM3BModel.x.GetElementsAt(
                resultElementsAbstractFactory.CreatexResultElementFactory(),
                resultsAbstractFactory.CreatexFactory(),
                HM3BModel.srt);

            this.SurgeonOperatingRoomDayAssignments = x
                                                      .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonNumberAssignedOperatingRooms
            this.SurgeonNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsFactory(),
                calculationsAbstractFactory.CreateSurgeonNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
                HM3BModel.s,
                x)
                                                       .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonNumberAssignedWeekdays
            this.SurgeonNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysFactory(),
                calculationsAbstractFactory.CreateSurgeonNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
                HM3BModel.s,
                x)
                                                 .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgeonScenarioNumberPatients
            ISurgeonScenarioNumberPatients surgeonScenarioNumberPatients = calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementFactory(),
                resultsAbstractFactory.CreateSurgeonScenarioNumberPatientsFactory(),
                calculationsAbstractFactory.CreateSurgeonScenarioNumberPatientsResultElementCalculationFactory().Create(),
                HM3BModel.rt,
                HM3BModel.sΛ,
                HM3BModel.n,
                x);

            this.SurgeonScenarioNumberPatients = surgeonScenarioNumberPatients.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgicalSpecialtyNumberAssignedOperatingRooms
            this.SurgicalSpecialtyNumberAssignedOperatingRooms = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementFactory(),
                resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsFactory(),
                calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedOperatingRoomsResultElementCalculationFactory().Create(),
                HM3BModel.Δ,
                x)
                                                                 .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // SurgicalSpecialtyNumberAssignedWeekdays
            this.SurgicalSpecialtyNumberAssignedWeekdays = calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysCalculationFactory().Create().Calculate(
                resultElementsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementFactory(),
                resultsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysFactory(),
                calculationsAbstractFactory.CreateSurgicalSpecialtyNumberAssignedWeekdaysResultElementCalculationFactory().Create(),
                HM3BModel.Δ,
                x)
                                                           .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // y(s, r)
            Iy y = HM3BEncodingEnum switch
            {
                HM3BEncodingEnum.E001 => ((IHM3B001Model)HM3BModel).y.GetElementsAt(
                    resultElementsAbstractFactory.CreateyResultElementFactory(),
                    resultsAbstractFactory.CreateyFactory(),
                    ((IHM3B001Model)HM3BModel).sr),

                HM3BEncodingEnum.E011 => ((IHM3B011Model)HM3BModel).y.GetElementsAt(
                    resultElementsAbstractFactory.CreateyResultElementFactory(),
                    resultsAbstractFactory.CreateyFactory(),
                    ((IHM3B011Model)HM3BModel).sr),

                HM3BEncodingEnum.E101 => ((IHM3B101Model)HM3BModel).y.GetElementsAt(
                    resultElementsAbstractFactory.CreateyResultElementFactory(),
                    resultsAbstractFactory.CreateyFactory(),
                    ((IHM3B101Model)HM3BModel).sr),

                HM3BEncodingEnum.E111 => ((IHM3B111Model)HM3BModel).y.GetElementsAt(
                    resultElementsAbstractFactory.CreateyResultElementFactory(),
                    resultsAbstractFactory.CreateyFactory(),
                    ((IHM3B111Model)HM3BModel).sr),

                _ => null
            };

            if (y != null)
            {
                this.SurgeonOperatingRoomAssignments = y
                                                       .GetValueForOutputContext(
                    dependenciesAbstractFactory.CreateNullableValueFactory());
            }

            // z(s, t)
            Iz z = HM3BModel.z.GetElementsAt(
                resultElementsAbstractFactory.CreatezResultElementFactory(),
                resultsAbstractFactory.CreatezFactory(),
                HM3BModel.st);

            this.SurgeonDayAssignments = z
                                         .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // β(s, r, d)
            this.SurgeonOperatingRoomDayNumberAssignedTimeBlocks = HM3BModel.β.GetElementsAt(
                resultElementsAbstractFactory.CreateβResultElementFactory(),
                resultsAbstractFactory.CreateβFactory(),
                HM3BModel.srd)
                                                                   .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // γ(r, t)
            this.OperatingRoomDayAssignedAvailabilities = HM3BModel.γ.GetElementsAt(
                resultElementsAbstractFactory.CreateγResultElementFactory(),
                resultsAbstractFactory.CreateγFactory(),
                HM3BModel.rt)
                                                          .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioNumberPatients(Λ)
            this.ScenarioNumberPatients = calculationsAbstractFactory.CreateScenarioNumberPatientsCalculationFactory().Create()
                                          .Calculate(
                resultElementsAbstractFactory.CreateScenarioNumberPatientsResultElementFactory(),
                resultsAbstractFactory.CreateScenarioNumberPatientsFactory(),
                calculationsAbstractFactory.CreateScenarioNumberPatientsResultElementCalculationFactory().Create(),
                HM3BModel.Λ,
                surgeonScenarioNumberPatients)
                                          .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ExpectedValueΦ(s, l, Λ)
            IExpectedValueΦ expectedValueΦ = calculationsAbstractFactory.CreateExpectedValueΦCalculationFactory().Create()
                                             .Calculate(
                resultElementsAbstractFactory.CreateExpectedValueΦResultElementFactory(),
                resultsAbstractFactory.CreateExpectedValueΦFactory(),
                calculationsAbstractFactory.CreateExpectedValueΦResultElementCalculationFactory().Create(),
                HM3BModel.l,
                HM3BModel.t,
                HM3BModel.slΛ,
                HM3BModel.L,
                HM3BModel.p,
                HM3BModel.μ);

            // VarianceΦ(s, l, Λ)
            IVarianceΦ varianceΦ = calculationsAbstractFactory.CreateVarianceΦCalculationFactory().Create()
                                   .Calculate(
                resultElementsAbstractFactory.CreateVarianceΦResultElementFactory(),
                resultsAbstractFactory.CreateVarianceΦFactory(),
                calculationsAbstractFactory.CreateVarianceΦResultElementCalculationFactory().Create(),
                HM3BModel.l,
                HM3BModel.t,
                HM3BModel.slΛ,
                HM3BModel.L,
                HM3BModel.p,
                HM3BModel.μ,
                HM3BModel.σ);

            // ExpectedValueI(t, Λ)
            Interfaces.Results.DayScenarioRecoveryWardUtilizations.IExpectedValueI expectedValueI = calculationsAbstractFactory.CreateExpectedValueICalculationFactory().Create()
                                                                                                    .Calculate(
                resultElementsAbstractFactory.CreateExpectedValueIResultElementFactory(),
                resultsAbstractFactory.CreateExpectedValueIFactory(),
                calculationsAbstractFactory.CreateExpectedValueIResultElementCalculationFactory().Create(),
                HM3BModel.l,
                HM3BModel.t,
                HM3BModel.st,
                HM3BModel.tΛ,
                expectedValueΦ,
                z);

            this.DayScenarioRecoveryWardUtilizationExpectedValues = expectedValueI
                                                                    .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // VarianceI(t, Λ)
            IVarianceI varianceI = calculationsAbstractFactory.CreateVarianceICalculationFactory().Create()
                                   .Calculate(
                resultElementsAbstractFactory.CreateVarianceIResultElementFactory(),
                resultsAbstractFactory.CreateVarianceIFactory(),
                calculationsAbstractFactory.CreateVarianceIResultElementCalculationFactory().Create(),
                HM3BModel.l,
                HM3BModel.t,
                HM3BModel.st,
                HM3BModel.tΛ,
                varianceΦ,
                z);

            this.DayScenarioRecoveryWardUtilizationVariances = varianceI
                                                               .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // EBS(t, Λ)
            IEBS EBS = calculationsAbstractFactory.CreateEBSCalculationFactory().Create()
                       .Calculate(
                resultElementsAbstractFactory.CreateEBSResultElementFactory(),
                resultsAbstractFactory.CreateEBSFactory(),
                calculationsAbstractFactory.CreateEBSResultElementCalculationFactory().Create(),
                HM3BModel.tΛ,
                HM3BModel.Ω,
                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(),
                HM3BModel.t,
                HM3BModel.Λ,
                EBS);

            this.ScenarioTotalExpectedBedShortages = TEBS_Λ
                                                     .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // TEBS
            this.TotalExpectedBedShortage = calculationsAbstractFactory.CreateTEBSCalculationFactory().Create()
                                            .Calculate(
                resultsAbstractFactory.CreateTEBSFactory(),
                HM3BModel.Λ,
                HM3BModel.Ρ,
                TEBS_Λ)
                                            .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioTotalTimes(Λ)
            IScenarioTotalTimes scenarioTotalTimes = calculationsAbstractFactory.CreateScenarioTotalTimesCalculationFactory().Create()
                                                     .Calculate(
                resultElementsAbstractFactory.CreateScenarioTotalTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioTotalTimesFactory(),
                calculationsAbstractFactory.CreateScenarioTotalTimesResultElementCalculationFactory().Create(),
                HM3BModel.Λ,
                HM3BModel.srt,
                HM3BModel.H,
                x);

            this.ScenarioTotalTimes = scenarioTotalTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUtilizedTimes(Λ)
            IScenarioUtilizedTimes scenarioUtilizedTimes = calculationsAbstractFactory.CreateScenarioUtilizedTimesCalculationFactory().Create()
                                                           .Calculate(
                resultElementsAbstractFactory.CreateScenarioUtilizedTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUtilizedTimesFactory(),
                calculationsAbstractFactory.CreateScenarioUtilizedTimesResultElementCalculationFactory().Create(),
                HM3BModel.Λ,
                HM3BModel.srt,
                HM3BModel.h,
                HM3BModel.n,
                x);

            this.ScenarioUtilizedTimes = scenarioUtilizedTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUnutilizedTimes(Λ)
            IScenarioUnutilizedTimes scenarioUnutilizedTimes = calculationsAbstractFactory.CreateScenarioUnutilizedTimesCalculationFactory().Create()
                                                               .Calculate(
                resultElementsAbstractFactory.CreateScenarioUnutilizedTimesResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUnutilizedTimesFactory(),
                calculationsAbstractFactory.CreateScenarioUnutilizedTimesResultElementCalculationFactory().Create(),
                HM3BModel.Λ,
                scenarioTotalTimes,
                scenarioUtilizedTimes);

            this.ScenarioUnutilizedTimes = scenarioUnutilizedTimes.GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ScenarioUnderutilizations(Λ)
            this.ScenarioUnderutilizations = calculationsAbstractFactory.CreateScenarioUnderutilizationsCalculationFactory().Create()
                                             .Calculate(
                resultElementsAbstractFactory.CreateScenarioUnderutilizationsResultElementFactory(),
                resultsAbstractFactory.CreateScenarioUnderutilizationsFactory(),
                calculationsAbstractFactory.CreateScenarioUnderutilizationsResultElementCalculationFactory().Create(),
                HM3BModel.Λ,
                scenarioTotalTimes,
                scenarioUnutilizedTimes)
                                             .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());

            // ΦHat(s, l, Λ)
            this.SurgeonDayScenarioCumulativeNumberPatients = calculationsAbstractFactory.CreateΦHatCalculationFactory().Create()
                                                              .Calculate(
                calculationsAbstractFactory.CreateExpectedValueIResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateExpectedValueΦResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateVarianceIResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateVarianceΦResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateVHatResultElementCalculationFactory(),
                calculationsAbstractFactory.Createυ2ResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateΦHatResultElementCalculationFactory(),
                calculationsAbstractFactory.CreateExpectedValueICalculationFactory(),
                calculationsAbstractFactory.CreateExpectedValueΦCalculationFactory(),
                calculationsAbstractFactory.CreateMRNBCalculationFactory(),
                calculationsAbstractFactory.CreateRNBCalculationFactory(),
                calculationsAbstractFactory.CreatetStarCalculationFactory(),
                calculationsAbstractFactory.CreateVarianceICalculationFactory(),
                calculationsAbstractFactory.CreateVarianceΦCalculationFactory(),
                calculationsAbstractFactory.CreateVHatCalculationFactory(),
                calculationsAbstractFactory.Createυ2CalculationFactory(),
                dependenciesAbstractFactory.CreateNormalFactory(),
                resultElementsAbstractFactory.CreateExpectedValueIResultElementFactory(),
                resultElementsAbstractFactory.CreateExpectedValueΦResultElementFactory(),
                resultElementsAbstractFactory.CreateVarianceIResultElementFactory(),
                resultElementsAbstractFactory.CreateVarianceΦResultElementFactory(),
                resultElementsAbstractFactory.CreateVHatResultElementFactory(),
                resultElementsAbstractFactory.Createυ2ResultElementFactory(),
                resultElementsAbstractFactory.CreateΦHatResultElementFactory(),
                resultsAbstractFactory.CreateExpectedValueIFactory(),
                resultsAbstractFactory.CreateExpectedValueΦFactory(),
                resultsAbstractFactory.CreateVarianceIFactory(),
                resultsAbstractFactory.CreateVarianceΦFactory(),
                resultsAbstractFactory.CreateVHatFactory(),
                resultsAbstractFactory.Createυ2Factory(),
                resultsAbstractFactory.CreateΦHatFactory(),
                HM3BModel.l,
                HM3BModel.t,
                HM3BModel.Λ,
                HM3BModel.slΛ,
                HM3BModel.st,
                HM3BModel.tΛ,
                HM3BModel.L,
                HM3BModel.p,
                HM3BModel.μ,
                HM3BModel.σ,
                HM3BModel.Ω,
                z)
                                                              .GetValueForOutputContext(
                dependenciesAbstractFactory.CreateNullableValueFactory());
        }