public void Create_HasCalculationOutput_EntityHasPipingCalculationOutputEntity()
{
// Setup
var registry = new PersistenceRegistry();
SemiProbabilisticPipingOutput newOutput = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
var calculation = new SemiProbabilisticPipingCalculationScenario
{
Output = newOutput
};
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0);
// Assert
SemiProbabilisticPipingCalculationOutputEntity outputEntity = entity.SemiProbabilisticPipingCalculationOutputEntities.SingleOrDefault();
Assert.IsNotNull(outputEntity);
Assert.AreEqual(newOutput.HeaveFactorOfSafety, outputEntity.HeaveFactorOfSafety);
Assert.AreEqual(newOutput.SellmeijerFactorOfSafety, outputEntity.SellmeijerFactorOfSafety);
Assert.AreEqual(newOutput.UpliftFactorOfSafety, outputEntity.UpliftFactorOfSafety);
Assert.AreEqual(newOutput.UpliftEffectiveStress, outputEntity.UpliftEffectiveStress, newOutput.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(newOutput.HeaveGradient, outputEntity.HeaveGradient, newOutput.HeaveGradient.GetAccuracy());
Assert.AreEqual(newOutput.SellmeijerCreepCoefficient, outputEntity.SellmeijerCreepCoefficient, newOutput.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(newOutput.SellmeijerCriticalFall, outputEntity.SellmeijerCriticalFall, newOutput.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(newOutput.SellmeijerReducedFall, outputEntity.SellmeijerReducedFall, newOutput.SellmeijerReducedFall.GetAccuracy());
}
public void Read_ValidEntityWithNullParameterValues_ReturnSemiProbabilisticPipingOutput()
{
// Setup
var entity = new SemiProbabilisticPipingCalculationOutputEntity
{
HeaveFactorOfSafety = null,
UpliftFactorOfSafety = null,
SellmeijerFactorOfSafety = null,
UpliftEffectiveStress = null,
HeaveGradient = null,
SellmeijerCreepCoefficient = null,
SellmeijerCriticalFall = null,
SellmeijerReducedFall = null
};
// Call
SemiProbabilisticPipingOutput output = entity.Read();
// Assert
Assert.IsNaN(output.HeaveFactorOfSafety);
Assert.IsNaN(output.SellmeijerFactorOfSafety);
Assert.IsNaN(output.UpliftFactorOfSafety);
Assert.IsNaN(output.UpliftEffectiveStress);
Assert.IsNaN(output.HeaveGradient);
Assert.IsNaN(output.SellmeijerCreepCoefficient);
Assert.IsNaN(output.SellmeijerCriticalFall);
Assert.IsNaN(output.SellmeijerReducedFall);
}
public void Read_EntityWithSemiProbabilisticPipingCalculationOutputEntity_CalculationWithSemiProbabilisticPipingOutput()
{
// Setup
var entity = new SemiProbabilisticPipingCalculationEntity
{
SemiProbabilisticPipingCalculationOutputEntities =
{
new SemiProbabilisticPipingCalculationOutputEntity()
},
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
SemiProbabilisticPipingOutput output = calculation.Output;
Assert.IsNotNull(output);
Assert.IsNaN(output.HeaveFactorOfSafety);
Assert.IsNaN(output.SellmeijerFactorOfSafety);
Assert.IsNaN(output.UpliftFactorOfSafety);
Assert.IsNaN(output.UpliftEffectiveStress);
Assert.IsNaN(output.HeaveGradient);
Assert.IsNaN(output.SellmeijerCreepCoefficient);
Assert.IsNaN(output.SellmeijerCriticalFall);
Assert.IsNaN(output.SellmeijerReducedFall);
}
public void Create_AllOutputValuesSet_ReturnEntity()
{
// Setup
var pipingOutput = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftFactorOfSafety = 2.2,
HeaveFactorOfSafety = 4.4,
SellmeijerFactorOfSafety = 6.6,
UpliftEffectiveStress = 7.7,
HeaveGradient = 8.8,
SellmeijerCreepCoefficient = 9.9,
SellmeijerCriticalFall = 10.10,
SellmeijerReducedFall = 11.11
});
// Call
SemiProbabilisticPipingCalculationOutputEntity entity = pipingOutput.Create();
// Assert
Assert.AreEqual(pipingOutput.HeaveFactorOfSafety, entity.HeaveFactorOfSafety);
Assert.AreEqual(pipingOutput.SellmeijerFactorOfSafety, entity.SellmeijerFactorOfSafety);
Assert.AreEqual(pipingOutput.UpliftFactorOfSafety, entity.UpliftFactorOfSafety);
Assert.AreEqual(pipingOutput.UpliftEffectiveStress, entity.UpliftEffectiveStress, pipingOutput.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(pipingOutput.HeaveGradient, entity.HeaveGradient, pipingOutput.HeaveGradient.GetAccuracy());
Assert.AreEqual(pipingOutput.SellmeijerCreepCoefficient, entity.SellmeijerCreepCoefficient, pipingOutput.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(pipingOutput.SellmeijerCriticalFall, entity.SellmeijerCriticalFall, pipingOutput.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(pipingOutput.SellmeijerReducedFall, entity.SellmeijerReducedFall, pipingOutput.SellmeijerReducedFall.GetAccuracy());
}
public void Read_ValidEntity_ReturnSemiProbabilisticPipingOutput()
{
// Setup
var entity = new SemiProbabilisticPipingCalculationOutputEntity
{
HeaveFactorOfSafety = 9.8,
UpliftFactorOfSafety = 3.2,
SellmeijerFactorOfSafety = 8.7,
UpliftEffectiveStress = 15.2,
HeaveGradient = 12.2,
SellmeijerCreepCoefficient = 1.4,
SellmeijerCriticalFall = 6.2,
SellmeijerReducedFall = 8.1
};
// Call
SemiProbabilisticPipingOutput output = entity.Read();
// Assert
Assert.AreEqual(entity.HeaveFactorOfSafety, output.HeaveFactorOfSafety);
Assert.AreEqual(entity.SellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety);
Assert.AreEqual(entity.UpliftFactorOfSafety, output.UpliftFactorOfSafety);
Assert.AreEqual(entity.UpliftEffectiveStress, output.UpliftEffectiveStress.Value);
Assert.AreEqual(entity.HeaveGradient, output.HeaveGradient.Value);
Assert.AreEqual(entity.SellmeijerCreepCoefficient, output.SellmeijerCreepCoefficient.Value);
Assert.AreEqual(entity.SellmeijerCriticalFall, output.SellmeijerCriticalFall.Value);
Assert.AreEqual(entity.SellmeijerReducedFall, output.SellmeijerReducedFall.Value);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
SemiProbabilisticPipingOutput original = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(SemiProbabilisticPipingOutput original, SemiProbabilisticPipingOutput clone)
{
Assert.AreEqual(original.UpliftFactorOfSafety, clone.UpliftFactorOfSafety);
Assert.AreEqual(original.HeaveFactorOfSafety, clone.HeaveFactorOfSafety);
Assert.AreEqual(original.SellmeijerFactorOfSafety, clone.SellmeijerFactorOfSafety);
Assert.AreEqual(original.UpliftEffectiveStress, clone.UpliftEffectiveStress);
Assert.AreEqual(original.HeaveGradient, clone.HeaveGradient);
Assert.AreEqual(original.SellmeijerCreepCoefficient, clone.SellmeijerCreepCoefficient);
Assert.AreEqual(original.SellmeijerCriticalFall, clone.SellmeijerCriticalFall);
Assert.AreEqual(original.SellmeijerReducedFall, clone.SellmeijerReducedFall);
}
public void Constructor_ExpectedValues()
{
// Setup
SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
// Call
var properties = new SemiProbabilisticPipingOutputProperties(output, 0.1);
// Assert
Assert.IsInstanceOf <ObjectProperties <SemiProbabilisticPipingOutput> >(properties);
Assert.AreSame(output, properties.Data);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
const double norm = 0.1;
var random = new Random(22);
double upliftEffectiveStress = random.NextDouble();
double heaveGradient = random.NextDouble();
double sellmeijerCreepCoefficient = random.NextDouble();
double sellmeijerCriticalFall = random.NextDouble();
double sellmeijerReducedFall = random.NextDouble();
double upliftFactorOfSafety = random.NextDouble();
double heaveFactorOfSafety = random.NextDouble();
double sellmeijerFactorOfSafety = random.NextDouble();
var output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftEffectiveStress = upliftEffectiveStress,
HeaveGradient = heaveGradient,
SellmeijerCreepCoefficient = sellmeijerCreepCoefficient,
SellmeijerCriticalFall = sellmeijerCriticalFall,
SellmeijerReducedFall = sellmeijerReducedFall,
UpliftFactorOfSafety = upliftFactorOfSafety,
HeaveFactorOfSafety = heaveFactorOfSafety,
SellmeijerFactorOfSafety = sellmeijerFactorOfSafety
});
// Call
var properties = new SemiProbabilisticPipingOutputProperties(output, norm);
// Assert
DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(output, norm);
Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, properties.UpliftFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.UpliftReliability, properties.UpliftReliability, properties.UpliftReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.UpliftProbability), properties.UpliftProbability);
Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, properties.HeaveFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.HeaveReliability, properties.HeaveReliability, properties.HeaveReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.HeaveProbability), properties.HeaveProbability);
Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.SellmeijerReliability, properties.SellmeijerReliability, properties.SellmeijerReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.SellmeijerProbability), properties.SellmeijerProbability);
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.PipingProbability), properties.PipingProbability);
Assert.AreEqual(expectedDerivedOutput.PipingReliability, properties.PipingReliability, properties.PipingReliability.GetAccuracy());
Assert.AreEqual(upliftEffectiveStress, properties.UpliftEffectiveStress, properties.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(heaveGradient, properties.HeaveGradient, properties.HeaveGradient.GetAccuracy());
Assert.AreEqual(sellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(sellmeijerCriticalFall, properties.SellmeijerCriticalFall, properties.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(sellmeijerReducedFall, properties.SellmeijerReducedFall, properties.SellmeijerReducedFall.GetAccuracy());
}
public void Constructor_ConstructionPropertiesWithoutValuesSet_PropertiesAreDefault()
{
// Call
var semiProbabilisticPipingOutput = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
// Assert
Assert.IsNaN(semiProbabilisticPipingOutput.UpliftFactorOfSafety);
Assert.IsNaN(semiProbabilisticPipingOutput.HeaveFactorOfSafety);
Assert.IsNaN(semiProbabilisticPipingOutput.SellmeijerFactorOfSafety);
Assert.IsNaN(semiProbabilisticPipingOutput.UpliftEffectiveStress);
Assert.IsNaN(semiProbabilisticPipingOutput.HeaveGradient);
Assert.IsNaN(semiProbabilisticPipingOutput.SellmeijerCreepCoefficient);
Assert.IsNaN(semiProbabilisticPipingOutput.SellmeijerCriticalFall);
Assert.IsNaN(semiProbabilisticPipingOutput.SellmeijerReducedFall);
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(22);
double foSuValue = random.NextDouble();
double foShValue = random.NextDouble();
double foSsValue = random.NextDouble();
double upliftEffectiveStress = random.NextDouble();
double heaveGradient = random.NextDouble();
double sellmeijerCreepCoefficient = random.NextDouble();
double sellmeijerCriticalFall = random.NextDouble();
double sellmeijerReducedFall = random.NextDouble();
// Call
var output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftFactorOfSafety = foSuValue,
HeaveFactorOfSafety = foShValue,
SellmeijerFactorOfSafety = foSsValue,
UpliftEffectiveStress = upliftEffectiveStress,
HeaveGradient = heaveGradient,
SellmeijerCreepCoefficient = sellmeijerCreepCoefficient,
SellmeijerCriticalFall = sellmeijerCriticalFall,
SellmeijerReducedFall = sellmeijerReducedFall
});
// Assert
Assert.IsInstanceOf <CloneableObservable>(output);
Assert.IsInstanceOf <ICalculationOutput>(output);
Assert.AreEqual(foSuValue, output.UpliftFactorOfSafety);
Assert.AreEqual(foShValue, output.HeaveFactorOfSafety);
Assert.AreEqual(foSsValue, output.SellmeijerFactorOfSafety);
Assert.AreEqual(2, output.UpliftEffectiveStress.NumberOfDecimalPlaces);
Assert.AreEqual(upliftEffectiveStress, output.UpliftEffectiveStress, output.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(2, output.HeaveGradient.NumberOfDecimalPlaces);
Assert.AreEqual(heaveGradient, output.HeaveGradient, output.HeaveGradient.GetAccuracy());
Assert.AreEqual(1, output.SellmeijerCreepCoefficient.NumberOfDecimalPlaces);
Assert.AreEqual(sellmeijerCreepCoefficient, output.SellmeijerCreepCoefficient, output.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(2, output.SellmeijerCriticalFall.NumberOfDecimalPlaces);
Assert.AreEqual(sellmeijerCriticalFall, output.SellmeijerCriticalFall, output.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(2, output.SellmeijerReducedFall.NumberOfDecimalPlaces);
Assert.AreEqual(sellmeijerReducedFall, output.SellmeijerReducedFall, output.SellmeijerReducedFall.GetAccuracy());
}
public void Create_AllOutputValuesNaN_ReturnEntityWithNullValues()
{
// Setup
var pipingOutput = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
// Call
SemiProbabilisticPipingCalculationOutputEntity entity = pipingOutput.Create();
// Assert
Assert.IsNull(entity.HeaveFactorOfSafety);
Assert.IsNull(entity.SellmeijerFactorOfSafety);
Assert.IsNull(entity.UpliftFactorOfSafety);
Assert.IsNull(entity.UpliftEffectiveStress);
Assert.IsNull(entity.HeaveGradient);
Assert.IsNull(entity.SellmeijerCreepCoefficient);
Assert.IsNull(entity.SellmeijerCriticalFall);
Assert.IsNull(entity.SellmeijerReducedFall);
}
public void Create_ValidData_ReturnsExpectedValue()
{
// Setup
var calculatorResult = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftFactorOfSafety = 1.2,
HeaveFactorOfSafety = 1.4,
SellmeijerFactorOfSafety = 0.9
});
// Call
DerivedSemiProbabilisticPipingOutput derivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculatorResult, 0.1);
// Assert
Assert.AreEqual(0.0030333773290253025, derivedOutput.UpliftProbability, 1e-6);
Assert.AreEqual(0.00017624686431291146, derivedOutput.HeaveProbability, 1e-6);
Assert.AreEqual(0.13596896289025881, derivedOutput.SellmeijerProbability, 1e-6);
Assert.AreEqual(3.57331, derivedOutput.PipingReliability, derivedOutput.PipingReliability.GetAccuracy());
}
/// <summary>
/// Creates a <see cref="SemiProbabilisticPipingCalculationOutputEntity"/> based on the information
/// of the <see cref="SemiProbabilisticPipingOutput"/>.
/// </summary>
/// <param name="output">The calculation output for piping failure mechanism to
/// create a database entity for.</param>
/// <returns>A new <see cref="SemiProbabilisticPipingCalculationOutputEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/>
/// is <c>null</c>.</exception>
public static SemiProbabilisticPipingCalculationOutputEntity Create(this SemiProbabilisticPipingOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var entity = new SemiProbabilisticPipingCalculationOutputEntity
{
HeaveFactorOfSafety = output.HeaveFactorOfSafety.ToNaNAsNull(),
SellmeijerFactorOfSafety = output.SellmeijerFactorOfSafety.ToNaNAsNull(),
UpliftFactorOfSafety = output.UpliftFactorOfSafety.ToNaNAsNull(),
UpliftEffectiveStress = output.UpliftEffectiveStress.ToNaNAsNull(),
HeaveGradient = output.HeaveGradient.ToNaNAsNull(),
SellmeijerCreepCoefficient = output.SellmeijerCreepCoefficient.ToNaNAsNull(),
SellmeijerCriticalFall = output.SellmeijerCriticalFall.ToNaNAsNull(),
SellmeijerReducedFall = output.SellmeijerReducedFall.ToNaNAsNull()
};
return(entity);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
var failureMechanism = new PipingFailureMechanism();
// Call
var context = new SemiProbabilisticPipingOutputContext(output, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <WrappedObjectContextBase <SemiProbabilisticPipingOutput> >(context);
Assert.AreSame(output, context.WrappedData);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocks.VerifyAll();
}
public void CreateInstance_ValidData_NewPropertiesWithPipingOutputAsData()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
var context = new SemiProbabilisticPipingOutputContext(output, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <SemiProbabilisticPipingOutputProperties>(objectProperties);
Assert.AreSame(output, objectProperties.Data);
mocks.VerifyAll();
}
private static void AddEntityForPipingOutput(SemiProbabilisticPipingCalculationEntity entity, SemiProbabilisticPipingOutput output)
{
if (output != null)
{
entity.SemiProbabilisticPipingCalculationOutputEntities.Add(output.Create());
}
}
public override void ClearOutput()
{
Output = null;
}
