public void GenericStrategyWorksInMemory()
{
var calc1 = new CalculationInput()
{
Number1 = 5, Number2 = 3
};
var op1 = new Operator()
{
Operation = OperatorEnum.Addition
};
var op2 = new Operator()
{
Operation = OperatorEnum.Subtraktion
};
var factory = new MemoryOperatorStrategyLocator();
var strategyProvider = new GenericStrategyProvider <IOperatorStrategy, Operator>(factory);
IOperatorStrategy strategy;
strategy = strategyProvider.GetStrategy(op1);
strategy.DoCalculate(calc1).Should().Be(8);
strategy = strategyProvider.GetStrategy(op2);
strategy.DoCalculate(calc1).Should().Be(2);
}
private async Task <CalculationResult> CalculateResult(CalculationInput input, Func <Probability, Probability, Probability> calculation, string type)
{
var validationResult = _validator.Validate(input);
if (!validationResult.IsValid)
{
return new CalculationResult {
Validation = validationResult
}
}
;
var A = new Probability(input.A);
var B = new Probability(input.B);
var result = new CalculationResult
{
Validation = validationResult,
Result = calculation(A, B).Value,
CalculationDate = DateTime.UtcNow,
Inputs = new[] { A, B },
TypeOfCalculation = type
};
await _loggingService.LogAsync(result);
return(result);
}
}
private void HandleCalculationInputUpdated(CalculationInput calculationInput)
{
if (calculationInput.ArcDuration.Manufacturer != null)
{
BreakerEnabled = true;
BreakerStyles = null;
BreakerStyles = new List <BreakerStyle>(_dataService.GetBreakerStyles().Where(o => o.ManufacturerId == calculationInput.ArcDuration.Manufacturer.Id).ToList());
if (calculationInput.ArcDuration.BreakerStyle != null)
{
TripUnitEnabled = true;
TripUnitTypes = _dataService.GetTripUnitTypes().Where(o => o.BreakerStyleId == calculationInput.ArcDuration.BreakerStyle.Id).ToList();
}
}
CalculationInput = calculationInput;
//if (CalculationInput.ArcDuration.Manufacturer != null && BreakerEnabled == false)
//{
// BreakerEnabled = true;
// BreakerStyles = _dataService.GetBreakerStyles().Where(o => o.ManufacturerId == CalculationInput.ArcDuration.Manufacturer.Id).ToList();
//}
//if (CalculationInput.ArcDuration.BreakerStyle != null && TripUnitEnabled == false)
//{
// TripUnitEnabled = true;
// TripUnitTypes = _dataService.GetTripUnitTypes().Where(o => o.BreakerStyleId == CalculationInput.ArcDuration.BreakerStyle.Id).ToList();
//}
SensorRatingErrorMessage = CalculationInput.GetStringError("SensorRating");
IsEnabled = (CalculationInput.SensorRating.HasValue && SensorRatingErrorMessage == null && CalculationInput.ArcDuration.Manufacturer != null && CalculationInput.ArcDuration != null && CalculationInput.ArcDuration.TripUnitType != null);
}
public CalculationResult Execute(CalculationInput input)
{
return(new CalculationResult
{
Value = SumProbabilities(input) - GetCombinedProbability(input)
});
}
public CalculationResult Execute(CalculationInput input)
{
return(new CalculationResult
{
Value = input.A * input.B
});
}
/// <summary>
/// Calculates the <see cref="BalancedFieldLengthOutput"/> based on <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The <see cref="BalancedFieldLengthCalculation"/> to calculate for.</param>
/// <returns>A <see cref="BalancedFieldLengthOutput"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception>
/// <exception cref="CreateKernelDataException">Thrown when the calculation input
/// could not be created for the kernel.</exception>
/// <exception cref="KernelCalculationException">Thrown when <see cref="AggregatedDistanceOutput"/>
/// could not be calculated.</exception>
public BalancedFieldLengthOutput Calculate(BalancedFieldLengthCalculation calculation)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
GeneralSimulationSettingsData generalSimulationSettings = calculation.SimulationSettings;
double density = generalSimulationSettings.Density;
int endVelocity = generalSimulationSettings.EndFailureVelocity;
double gravitationalAcceleration = generalSimulationSettings.GravitationalAcceleration;
EngineData engineData = calculation.EngineData;
int nrOfFailedEngines = engineData.NrOfFailedEngines;
AircraftData aircraftData = AircraftDataFactory.Create(calculation.AircraftData, engineData);
var integrator = new EulerIntegrator();
var outputs = new List <AggregatedDistanceOutput>();
for (int i = 0; i < endVelocity; i++)
{
var calculationInput = new CalculationInput(generalSimulationSettings,
i,
aircraftData,
integrator,
nrOfFailedEngines,
density,
gravitationalAcceleration);
AggregatedDistanceOutput output = CalculateDistances(calculationInput);
outputs.Add(output);
}
return(BalancedFieldLengthOutputFactory.Create(outputs));
}
private void HandleCalculationInputUpdated(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
NominalVoltageErrorMessage = CalculationInput.GetStringError("NominalVoltage");
SourceFaultCurrentErrorMessage = CalculationInput.GetStringError("SourceFaultCurrent");
HasErrors = NominalVoltageErrorMessage != null || SourceFaultCurrentErrorMessage != null;
IsEnabled = (CalculationInput.EquipmentType != null && CalculationInput.IsSolidGround.HasValue && CalculationInput.NominalVoltage.HasValue && CalculationInput.SourceFaultCurrent.HasValue && !HasErrors);
}
public async Task ExecuteAsync_Always_Validates()
{
var input = new CalculationInput();
var result = await this.sut.ExecuteAsync(CalculationType.Either, input);
this.inputValidatorMock.Verify(v => v.Validate(input));
}
private void UpdateCalculationInput(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
if (OriginalWorkingDistance == null && CalculationInput.WorkingDistance.HasValue)
{
OriginalWorkingDistance = CalculationInput.WorkingDistance.Value;
}
}
public DCCircuitDiagramViewModel(INavigationService navigationService, IUnityContainer container, ICalculationInput calculationInput, IEventAggregator eventAggregator)
{
_navigationService = navigationService;
_calculationInput = calculationInput as CalculationInput;
_eventAggregator = eventAggregator;
_eventAggregator.GetEvent <CalculationInputUpdated>().Subscribe(HandleCalculationInputUpdated);
_container = container;
}
private void HandleCalculationInputUpdated(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
ConductorPerPhaseErrorMessage = CalculationInput.GetStringError("ConductorPerPhase");
ConductorLengthErrorMessage = CalculationInput.GetStringError("ConductorLenght");
HasErrors = ConductorPerPhaseErrorMessage != null || ConductorLengthErrorMessage != null;
IsEnabled = (CalculationInput.ConductorSize != null && CalculationInput.ConductorPerPhase.HasValue && CalculationInput.ConductorLength.HasValue && !HasErrors);
}
private void HandleCalculationInputUpdated(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
PrimaryVoltageErrorMessage = CalculationInput.GetStringError("PrimaryVoltage");
XfmrImpedanceErrorMessage = CalculationInput.GetStringError("XfmrImpedance");
XfmrKVAErrorMessage = CalculationInput.GetStringError("XfmrKVA");
HasErrors = PrimaryVoltageErrorMessage != null || XfmrImpedanceErrorMessage != null || XfmrKVAErrorMessage != null;
IsEnabled = (CalculationInput.PrimaryVoltage.HasValue && CalculationInput.XfmrImpedance.HasValue && CalculationInput.XfmrKVA.HasValue && !HasErrors);
}
public ResultViewModel(INavigationService navigationService, IUnityContainer container, IDataService dataService, ICalculationInput calculationInput, IValidator <CalculationInput> validator, ICalculatorService calculatorService)
{
_navigationService = navigationService;
_dataService = dataService;
_calculationInput = calculationInput as CalculationInput;
_validator = validator;
_container = container;
_calculatorService = calculatorService;
}
public ACInputTwoViewModel(INavigationService navigationService, ICalculationInput calculationInput, IValidator <CalculationInput> validator, IUnityContainer container, IEventAggregator eventAggregator)
{
_navigationService = navigationService;
_calculationInput = calculationInput as CalculationInput;
_validator = validator;
_container = container;
_eventAggregator = eventAggregator;
_eventAggregator.GetEvent <CalculationInputUpdated>().Subscribe(HandleCalculationInputUpdated);
}
private async void Ok()
{
_isClicked = true;
CalculationInput = _container.Resolve <ICalculationInput>() as CalculationInput;
await _navigationService.NavigateAsync("app:///MasterPage/NavPage/CommonInput");
await PopupNavigation.PopAllAsync(true);
_isClicked = false;
}
private void HandleCalculationInputUpdated(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
SensorRatingErrorMessage = CalculationInput.GetStringError("SensorRating");
ArcDurationValueErrorMessage = CalculationInput.GetStringError("ArcDurationValue");
CalculationOutput.EstimatedArcFaultCurrent = _calculatorService.CalculateArcFaultCurrentAC(CalculationInput);
EstimatedArcFaultCurrent = CalculationOutput.EstimatedArcFaultCurrent * 1000;
CalculationOutput.MultipleOfSensorRating = _calculatorService.CalculateMultipleSensorRatingAC(CalculationInput, CalculationOutput.EstimatedArcFaultCurrent);
HasErrors = SensorRatingErrorMessage != null || ArcDurationValueErrorMessage != null;
IsEnabled = (CalculationInput.ArcDurationValue.HasValue && !HasErrors);
}
public async Task <IActionResult> EitherAOrB([FromBody] CalculationInput input)
{
var output = await _service.EitherAOrB(input);
if (!output.Validation.IsValid)
{
return(BadRequest(output.Validation));
}
return(Ok(output.Result));
}
public void CalcRiskCategoryAC([ValueSource(typeof(CalcNoXNoCAC), "GetCalculationInputSimples")] CalculationInputSimple inputSimple, [ValueSource(typeof(CalcNoXNoCAC), "GetCalculationOutputs")] CalculationOutput output)
{
CalculationInput input = Container.Resolve <ICalculationInput>() as CalculationInput;
MapCalculationInputSimpleToCalculationInput(ref input, ref inputSimple);
var riskCat = Calc.RiskCategoryAC(output);
var expected = output.HazardCat;
var real = riskCat;
Assert.AreEqual(expected, real);
}
public void CalcIncidentEnergyDistanceAC([ValueSource(typeof(CalcNoXNoCAC), "GetCalculationInputSimples")] CalculationInputSimple inputSimple, [ValueSource(typeof(CalcNoXNoCAC), "GetCalculationOutputs")] CalculationOutput output)
{
CalculationInput input = Container.Resolve <ICalculationInput>() as CalculationInput;
MapCalculationInputSimpleToCalculationInput(ref input, ref inputSimple);
decimal IE = Calc.CalcIncidentEnergyAC(input.WorkingDistance.Value, Calc.CalculateArcFaultCurrentAC(input)).Value;
var expected = RoundValue(output.IncidentEnergy);
var real = RoundValue(IE);
Assert.AreEqual(expected, real);
}
public void CalcFlashHazardBoundaryAC([ValueSource(typeof(CalcNoXNoCAC), "GetCalculationInputSimples")] CalculationInputSimple inputSimple, [ValueSource(typeof(CalcNoXNoCAC), "GetCalculationOutputs")] CalculationOutput output)
{
CalculationInput input = Container.Resolve <ICalculationInput>() as CalculationInput;
MapCalculationInputSimpleToCalculationInput(ref input, ref inputSimple);
var fhb = Calc.CalcFlashHazardBoundaryAC(Calc.CalculateArcFaultCurrentAC(input));
var expected = RoundValue(output.FPB);
var real = RoundValue(fhb);
Assert.AreEqual(expected, real);
}
public void CalcBoltedFaultCurrentAC([ValueSource(typeof(CalcNoXNoCAC), "GetCalculationInputSimples")] CalculationInputSimple inputSimple, [ValueSource(typeof(CalcNoXNoCAC), "GetCalculationOutputs")] CalculationOutput output)
{
CalculationInput input = Container.Resolve <ICalculationInput>() as CalculationInput;
MapCalculationInputSimpleToCalculationInput(ref input, ref inputSimple);
decimal bfc = Calc.CalcBoltedFaultCurrentAC(input);
var expected = RoundValue(output.BoltedFaultCurrent.Value);
var real = RoundValue(bfc);
Assert.AreEqual(expected, real);
}
public List <VisibilityModel> ShowingAndHidingService(CalculationInput calculationInput)
{
CalculationInput CalculationInput = calculationInput;
bool ShowAlternatingCurrentFields, ShowDirectCurrentFields, ShowConductorFields, ShowTransformerFields;
if (!CalculationInput.IsAlternatingCurrent.HasValue)
{
ShowAlternatingCurrentFields = CalculationInput.IsAlternatingCurrent ?? false;
ShowDirectCurrentFields = !CalculationInput.IsAlternatingCurrent ?? false;
ShowConductorFields = CalculationInput.HasCable ?? false;
ShowTransformerFields = CalculationInput.HasTransformer ?? false;
}
else
{
//HasErrors = calculationInput.ErrorCount > 0;
//ErrorCount = calculationInput.ErrorCount;
//IsDirectCurrent = !CalculationInput.IsAlternatingCurrent ?? false;
ShowConductorFields = false;
ShowTransformerFields = false;
ShowAlternatingCurrentFields = calculationInput.IsAlternatingCurrent ?? false;
ShowDirectCurrentFields = !calculationInput.IsAlternatingCurrent ?? false;
if (ShowAlternatingCurrentFields)
{
ShowConductorFields = calculationInput.HasCable ?? false;
ShowTransformerFields = calculationInput.HasTransformer ?? false;
}
// CalculationInput.HasTransformer = CalculationInput.IsAlternatingCurrent.HasValue && !CalculationInput.IsAlternatingCurrent.Value ? null : CalculationInput.HasTransformer;
}
List <VisibilityModel> Fields = new List <VisibilityModel>();
Fields.Add(new VisibilityModel()
{
Parameter = "ShowAlternatingCurrentFields", ParameterValue = ShowAlternatingCurrentFields
});
Fields.Add(new VisibilityModel()
{
Parameter = "ShowDirectCurrentFields", ParameterValue = ShowDirectCurrentFields
});
Fields.Add(new VisibilityModel()
{
Parameter = "ShowConductorFields", ParameterValue = ShowConductorFields
});
Fields.Add(new VisibilityModel()
{
Parameter = "ShowTransformerFields", ParameterValue = ShowTransformerFields
});
return(Fields);
// throw new NotImplementedException();
}
private void UpdateCalculationInput(CalculationInput calculationInput)
{
CalculationInput = calculationInput;
ErrorCount = CalculationInput.ErrorCount;
if (!CalculationInput.IsAlternatingCurrent.HasValue)
{
HasEstimatedArcFaultCurrent = false;
ShowAlternatingCurrentFields = CalculationInput.IsAlternatingCurrent ?? false;
ShowDirectCurrentFields = !CalculationInput.IsAlternatingCurrent ?? false;
ShowConductorFields = CalculationInput.HasCable ?? false;
ShowTransformerFields = CalculationInput.HasTransformer ?? false;
if (Manufacturers != null)
{
Manufacturers.SelectedItem = null;
}
if (BreakerStyles != null)
{
BreakerStyles.SelectedItem = null;
}
if (TripUnitTypes != null)
{
TripUnitTypes.SelectedItem = null;
}
}
else
{
IsReset = true;
EnableCableFields = CalculationInput.HasCable.HasValue ? CalculationInput.HasCable.Value : false;
EnableTransformerFields = CalculationInput.HasTransformer.HasValue ? CalculationInput.HasTransformer.Value : false;
HasRangeErrors = calculationInput.ErrorCount > 0;
HasErrors = !HasRangeErrors && calculationInput.HasErrors;
IsDirectCurrent = !CalculationInput.IsAlternatingCurrent ?? false;
ShowConductorFields = false;
ShowTransformerFields = false;
ShowAlternatingCurrentFields = calculationInput.IsAlternatingCurrent ?? false;
ShowDirectCurrentFields = !calculationInput.IsAlternatingCurrent ?? false;
if (ShowAlternatingCurrentFields)
{
ShowConductorFields = calculationInput.HasCable ?? false;
ShowTransformerFields = calculationInput.HasTransformer ?? false;
}
//do output calc
CalculationOutput.EstimatedArcFaultCurrent = _calculatorService.CalculateArcFaultCurrentAC(calculationInput);
EstimatedArcFaultCurrentInAmps = CalculationOutput.EstimatedArcFaultCurrent * 1000;
HasEstimatedArcFaultCurrent = EstimatedArcFaultCurrentInAmps != null;
CalculationOutput.MultipleOfSensorRating = _calculatorService.CalculateMultipleSensorRatingAC(calculationInput, CalculationOutput.EstimatedArcFaultCurrent);
_eventAggregator.GetEvent <CalculationOutputUpdated>().Publish(CalculationOutput);
}
}
public ACResultViewModel(IPdfCreatorService pdfCreator, ISaveAndLoad saveAndLoad, INavigationService navigationService, IUnityContainer container, IDataService dataService, ICalculationOutput calculationOutput, ICalculationInput calculationInput, ICalculatorService calculatorService, IPageDialogService dialogService, IEventAggregator eventAggregator)
{
_pdfCreator = pdfCreator;
_saveAndLoad = saveAndLoad;
_navigationService = navigationService;
_dataService = dataService;
_calculationInput = calculationInput as CalculationInput;
_calculationOutput = calculationOutput as CalculationOutput;
_container = container;
_calculatorService = calculatorService;
_dialogService = dialogService;
_eventAggregator = eventAggregator;
//_eventAggregator.GetEvent<CalculationOutputUpdated>().Subscribe(HandleCalculationOutputUpdated);
//_eventAggregator.GetEvent<CalculationInputUpdated>().Subscribe(HandleCalculationInputUpdated);
}
public void Should_fail_if_input_B_is_out_of_range(decimal b)
{
// arrange
var input = new CalculationInput
{
A = 0.5M,
B = b
};
// act
var actual = GetSubject().Validate(input);
// assert
actual.IsValid.Should().BeFalse();
actual.Error.Should().Be($"Value {b} for input is out of range. Must be between 0 and 1");
}
public void Should_pass_if_both_A_and_B_are_in_range(decimal a, decimal b)
{
// arrange
var input = new CalculationInput
{
A = a,
B = b
};
// act
var actual = GetSubject().Validate(input);
// assert
actual.IsValid.Should().BeTrue();
actual.Error.Should().BeNull();
}
private void UpdateArcDuration(ArcDuration arcDuration)
{
ArcDuration = arcDuration;
if (CalculationInput.ArcDuration.Manufacturer != null && BreakerEnabled == false)
{
BreakerEnabled = true;
BreakerStyles = new List <BreakerStyle>(_dataService.GetBreakerStyles().Where(o => o.ManufacturerId == CalculationInput.ArcDuration.Manufacturer.Id).ToList());
}
if (CalculationInput.ArcDuration.BreakerStyle != null && TripUnitEnabled == false)
{
TripUnitEnabled = true;
TripUnitTypes = _dataService.GetTripUnitTypes().Where(o => o.BreakerStyleId == CalculationInput.ArcDuration.BreakerStyle.Id).ToList();
}
SensorRatingErrorMessage = CalculationInput.GetStringError("SensorRating");
IsEnabled = (CalculationInput.SensorRating.HasValue && SensorRatingErrorMessage == null && CalculationInput.ArcDuration.Manufacturer != null && CalculationInput.ArcDuration != null && CalculationInput.ArcDuration.TripUnitType != null);
}
public async Task <CalculationResult> ExecuteAsync(CalculationType type, CalculationInput input)
{
this.calculationInputValidator.Validate(input);
var result = this.calculationFactory.Create(type).Execute(input);
await this.calculationAuditRepository.SaveAsync(new CalculationAudit
{
CalculationType = type,
Input = input,
Result = result,
Timestamp = DateTime.UtcNow
});
return(result);
}
public decimal?CalcIncidentEnergyL50DC(CalculationInput calculationInput)
{
if (!calculationInput.MaximumShortCircuitAvailable.HasValue)
{
return(null);
}
if (!calculationInput.InCabinet.HasValue)
{
return(null);
}
var cabinet = (calculationInput.InCabinet.Value) ? 3m : 1m;
decimal iE50 = cabinet * 0.01m * 48 * (calculationInput.MaximumShortCircuitAvailable.Value / 2m) * (2m / (45m * 45m));
return(iE50);
}
public async Task EitherAorB_should_return_ok_if_service_succeeds()
{
// arrange
var input = new CalculationInput();
var goodResponse = new CalculationResult {
Validation = ValidationResult.Success()
};
A.CallTo(() => _calculationService.EitherAOrB(input))
.Returns(goodResponse);
// act
var result = await GetSubject().EitherAOrB(input);
// assert
result.Should().BeOfType <OkObjectResult>();
}
