public void Read_EntityWithSurfaceLineInCollector_CalculationHasAlreadyReadSurfaceLine()
{
// Setup
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(1, 2, 3),
new Point3D(4, 5, 6)
});
var surfaceLineEntity = new SurfaceLineEntity();
var entity = new SemiProbabilisticPipingCalculationEntity
{
SurfaceLineEntity = surfaceLineEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(surfaceLineEntity, surfaceLine);
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(surfaceLine, calculation.InputParameters.SurfaceLine);
Assert.AreEqual(1, calculation.InputParameters.EntryPointL, 1e-6);
Assert.AreEqual(2, calculation.InputParameters.ExitPointL, 1e-6);
}
private static void SetInputParametersToEntity(SemiProbabilisticPipingCalculationEntity entity,
SemiProbabilisticPipingInput inputParameters,
PersistenceRegistry registry)
{
if (inputParameters.SurfaceLine != null)
{
entity.SurfaceLineEntity = registry.Get(inputParameters.SurfaceLine);
}
SetHydraulicBoundaryLocationInputToEntity(entity, inputParameters, registry);
if (inputParameters.StochasticSoilProfile != null)
{
entity.PipingStochasticSoilProfileEntity = registry.Get(inputParameters.StochasticSoilProfile);
}
entity.ExitPointL = inputParameters.ExitPointL.Value.ToNaNAsNull();
entity.EntryPointL = inputParameters.EntryPointL.Value.ToNaNAsNull();
entity.PhreaticLevelExitMean = inputParameters.PhreaticLevelExit.Mean.ToNaNAsNull();
entity.PhreaticLevelExitStandardDeviation = inputParameters.PhreaticLevelExit.StandardDeviation.ToNaNAsNull();
entity.DampingFactorExitMean = inputParameters.DampingFactorExit.Mean.ToNaNAsNull();
entity.DampingFactorExitStandardDeviation = inputParameters.DampingFactorExit.StandardDeviation.ToNaNAsNull();
}
public void Create_HasSurfaceLineSet_EntityHasSurfaceLineEntity()
{
// Setup
var surfaceLine = new PipingSurfaceLine(string.Empty)
{
ReferenceLineIntersectionWorldPoint = new Point2D(1.1, 2.2)
};
surfaceLine.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.3, 6.6, 1.0)
});
var registry = new PersistenceRegistry();
SurfaceLineEntity surfaceLineEntity = surfaceLine.Create(registry, 0);
var calculation = new SemiProbabilisticPipingCalculationScenario
{
InputParameters =
{
SurfaceLine = surfaceLine
}
};
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(surfaceLineEntity, entity.SurfaceLineEntity);
}
private static void AddEntityForPipingOutput(SemiProbabilisticPipingCalculationEntity entity, SemiProbabilisticPipingOutput output)
{
if (output != null)
{
entity.SemiProbabilisticPipingCalculationOutputEntities.Add(output.Create());
}
}
public void Read_EntityWithHydraulicBoundaryLocationInCollector_CalculationHasAlreadyReadHydraulicBoundaryLocation()
{
// Setup
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var hydraulicLocationEntity = new HydraulicLocationEntity();
var entity = new SemiProbabilisticPipingCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
AssessmentLevel = 5.81,
UseAssessmentLevelManualInput = Convert.ToByte(false),
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(hydraulicBoundaryLocation, calculation.InputParameters.HydraulicBoundaryLocation);
}
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_EntityWithStochasticSoilModelEntityInCollector_CalculationHasAlreadyReadStochasticSoilModel()
{
// Setup
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
var stochasticSoilModelEntity = new StochasticSoilModelEntity();
var stochasticSoilProfile = new PipingStochasticSoilProfile(1, PipingSoilProfileTestFactory.CreatePipingSoilProfile());
var stochasticSoilProfileEntity = new PipingStochasticSoilProfileEntity
{
StochasticSoilModelEntity = stochasticSoilModelEntity
};
var entity = new SemiProbabilisticPipingCalculationEntity
{
PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile);
collector.Read(stochasticSoilModelEntity, stochasticSoilModel);
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(stochasticSoilProfile, calculation.InputParameters.StochasticSoilProfile);
Assert.AreSame(stochasticSoilModel, calculation.InputParameters.StochasticSoilModel);
}
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_StochasticSoilProfileSet_EntityHasStochasticSoilProfileEntity()
{
// Setup
PipingSoilProfile soilProfile = PipingSoilProfileTestFactory.CreatePipingSoilProfile();
var stochasticSoilProfile = new PipingStochasticSoilProfile(0.6, soilProfile);
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A", new[]
{
stochasticSoilProfile
});
var registry = new PersistenceRegistry();
StochasticSoilModelEntity soilModelEntity = soilModel.Create(registry, 0);
var calculation = new SemiProbabilisticPipingCalculationScenario
{
InputParameters =
{
StochasticSoilModel = soilModel,
StochasticSoilProfile = stochasticSoilProfile
}
};
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0);
// Assert
PipingStochasticSoilProfileEntity expectedStochasticSoilProfileEntity = soilModelEntity.PipingStochasticSoilProfileEntities.First();
Assert.AreSame(expectedStochasticSoilProfileEntity, entity.PipingStochasticSoilProfileEntity);
Assert.IsTrue(registry.Contains(soilModel));
}
public void Read_EntityWithSurfaceLineNotYetInCollector_CalculationWithCreatedSurfaceLineAndRegisteredNewEntities()
{
// Setup
var points = new[]
{
new Point3D(1, 3, 4),
new Point3D(7, 10, 11)
};
var surfaceLineEntity = new SurfaceLineEntity
{
Name = "surface line",
PointsXml = new Point3DCollectionXmlSerializer().ToXml(points)
};
var entity = new SemiProbabilisticPipingCalculationEntity
{
SurfaceLineEntity = surfaceLineEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsTrue(collector.ContainsPipingSurfaceLine(surfaceLineEntity));
CollectionAssert.AreEqual(points, calculation.InputParameters.SurfaceLine.Points);
}
private static void ReadCalculationOutputs(SemiProbabilisticPipingCalculationScenario calculation,
SemiProbabilisticPipingCalculationEntity entity)
{
SemiProbabilisticPipingCalculationOutputEntity calculationOutputEntity = entity.SemiProbabilisticPipingCalculationOutputEntities.SingleOrDefault();
if (calculationOutputEntity != null)
{
calculation.Output = calculationOutputEntity.Read();
}
}
private static void SetHydraulicBoundaryLocationInputToEntity(SemiProbabilisticPipingCalculationEntity entity,
SemiProbabilisticPipingInput inputParameters,
PersistenceRegistry registry)
{
entity.UseAssessmentLevelManualInput = Convert.ToByte(inputParameters.UseAssessmentLevelManualInput);
entity.AssessmentLevel = inputParameters.AssessmentLevel.ToNaNAsNull();
if (inputParameters.HydraulicBoundaryLocation != null)
{
entity.HydraulicLocationEntity = registry.Get(inputParameters.HydraulicBoundaryLocation);
}
}
public void Read_CollectorIsNull_ThrowArgumentNullException()
{
// Setup
var entity = new SemiProbabilisticPipingCalculationEntity();
// Call
void Call() => entity.Read(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("collector", exception.ParamName);
}
public void Read_ValidEntity_ReturnSemiProbabilisticPipingCalculationScenario(
bool isRelevant, bool useAssessmentLevelManualInput, double contribution,
string name, string comments, double entryPoint, double exitPoint,
double assessmentLevel, int seed)
{
// Setup
var random = new Random(seed);
var entity = new SemiProbabilisticPipingCalculationEntity
{
RelevantForScenario = Convert.ToByte(isRelevant),
ScenarioContribution = contribution,
Name = name,
Comments = comments,
EntryPointL = entryPoint.ToNaNAsNull(),
ExitPointL = exitPoint.ToNaNAsNull(),
PhreaticLevelExitMean = random.NextDouble(-9999.99, 9999.99),
PhreaticLevelExitStandardDeviation = random.NextDouble(0, 9999.99),
DampingFactorExitMean = random.NextDouble(1e-6, 9999.99),
DampingFactorExitStandardDeviation = random.NextDouble(0, 9999.99),
AssessmentLevel = assessmentLevel.ToNaNAsNull(),
UseAssessmentLevelManualInput = Convert.ToByte(useAssessmentLevelManualInput)
};
var collector = new ReadConversionCollector();
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreEqual(isRelevant, calculation.IsRelevant);
RoundedDoubleTestHelper.AssertRoundedDouble(contribution, calculation.Contribution);
Assert.AreEqual(name, calculation.Name);
Assert.AreEqual(comments, calculation.Comments.Body);
RoundedDoubleTestHelper.AssertRoundedDouble(entryPoint, calculation.InputParameters.EntryPointL);
RoundedDoubleTestHelper.AssertRoundedDouble(exitPoint, calculation.InputParameters.ExitPointL);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.PhreaticLevelExitMean, calculation.InputParameters.PhreaticLevelExit.Mean);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.PhreaticLevelExitStandardDeviation, calculation.InputParameters.PhreaticLevelExit.StandardDeviation);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.DampingFactorExitMean, calculation.InputParameters.DampingFactorExit.Mean);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.DampingFactorExitStandardDeviation, calculation.InputParameters.DampingFactorExit.StandardDeviation);
Assert.AreEqual(useAssessmentLevelManualInput, calculation.InputParameters.UseAssessmentLevelManualInput);
Assert.AreEqual(entity.AssessmentLevel.ToNullAsNaN(), calculation.InputParameters.AssessmentLevel.Value);
Assert.IsNull(calculation.InputParameters.SurfaceLine);
Assert.IsNull(calculation.InputParameters.HydraulicBoundaryLocation);
Assert.IsNull(calculation.InputParameters.StochasticSoilModel);
Assert.IsNull(calculation.InputParameters.StochasticSoilProfile);
Assert.IsNull(calculation.Output);
}
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities()
{
// Setup
var calculationGroup = new CalculationGroup();
var semiProbabilisticPipingCalculationScenario = new SemiProbabilisticPipingCalculationScenario();
var probabilisticPipingCalculationScenario = new ProbabilisticPipingCalculationScenario();
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
failureMechanism.CalculationsGroup.Children.Add(semiProbabilisticPipingCalculationScenario);
failureMechanism.CalculationsGroup.Children.Add(probabilisticPipingCalculationScenario);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(1, childGroupEntities.Length);
CalculationGroupEntity childGroupEntity = childGroupEntities[0];
Assert.AreEqual(calculationGroup.Name, childGroupEntity.Name);
Assert.AreEqual(0, childGroupEntity.Order);
SemiProbabilisticPipingCalculationEntity[] semiProbabilisticPipingCalculationEntities = entity.CalculationGroupEntity
.SemiProbabilisticPipingCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
Assert.AreEqual(1, semiProbabilisticPipingCalculationEntities.Length);
SemiProbabilisticPipingCalculationEntity semiProbabilisticPipingCalculationEntity = semiProbabilisticPipingCalculationEntities[0];
Assert.AreEqual(semiProbabilisticPipingCalculationScenario.Name, semiProbabilisticPipingCalculationEntity.Name);
Assert.AreEqual(1, semiProbabilisticPipingCalculationEntity.Order);
ProbabilisticPipingCalculationEntity[] probabilisticPipingCalculationEntities = entity.CalculationGroupEntity
.ProbabilisticPipingCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
Assert.AreEqual(1, probabilisticPipingCalculationEntities.Length);
ProbabilisticPipingCalculationEntity probabilisticPipingCalculationEntity = probabilisticPipingCalculationEntities[0];
Assert.AreEqual(probabilisticPipingCalculationScenario.Name, probabilisticPipingCalculationEntity.Name);
Assert.AreEqual(2, probabilisticPipingCalculationEntity.Order);
}
public void Read_EntityWithStochasticSoilProfileEntityNotYetInCollector_CalculationWithCreatedStochasticSoilProfileAndRegisteredNewEntities()
{
// Setup
var stochasticSoilProfileEntity = new PipingStochasticSoilProfileEntity
{
PipingSoilProfileEntity = new PipingSoilProfileEntity
{
Name = "SoilProfile",
PipingSoilLayerEntities =
{
new PipingSoilLayerEntity()
}
}
};
var random = new Random(21);
var geometry = new[]
{
new Point2D(random.NextDouble(), random.NextDouble())
};
var stochasticSoilModelEntity = new StochasticSoilModelEntity
{
Name = "StochasticSoilModel",
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(geometry),
PipingStochasticSoilProfileEntities =
{
stochasticSoilProfileEntity
}
};
stochasticSoilProfileEntity.StochasticSoilModelEntity = stochasticSoilModelEntity;
var entity = new SemiProbabilisticPipingCalculationEntity
{
PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(stochasticSoilProfileEntity));
Assert.IsTrue(collector.ContainsPipingStochasticSoilModel(stochasticSoilModelEntity));
}
public void Create_HydraulicBoundaryLocation_EntityHasHydraulicLocationEntity()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 2.3, 4.5);
var registry = new PersistenceRegistry();
HydraulicLocationEntity hydraulicLocationEntity = hydraulicBoundaryLocation.Create(registry, 0);
var calculation = new SemiProbabilisticPipingCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicLocationEntity, entity.HydraulicLocationEntity);
}
public void Read_EntityWithHydraulicBoundaryLocationNotYetInCollector_CalculationWithCreatedHydraulicBoundaryLocationAndRegisteredNewEntities()
{
// Setup
HydraulicLocationEntity hydraulicLocationEntity = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var entity = new SemiProbabilisticPipingCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
UseAssessmentLevelManualInput = Convert.ToByte(false),
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(hydraulicLocationEntity));
}
/// <summary>
/// Creates a <see cref="SemiProbabilisticPipingCalculationEntity"/> based on the information
/// of the <see cref="SemiProbabilisticPipingCalculationScenario"/>.
/// </summary>
/// <param name="calculation">The piping calculation to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">The index at which <paramref name="calculation"/> resides within its parent.</param>
/// <returns>A new <see cref="SemiProbabilisticPipingCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
public static SemiProbabilisticPipingCalculationEntity Create(this SemiProbabilisticPipingCalculationScenario calculation,
PersistenceRegistry registry, int order)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var entity = new SemiProbabilisticPipingCalculationEntity
{
RelevantForScenario = Convert.ToByte(calculation.IsRelevant),
ScenarioContribution = calculation.Contribution,
Name = calculation.Name.DeepClone(),
Comments = calculation.Comments.Body.DeepClone(),
Order = order
};
SetInputParametersToEntity(entity, calculation.InputParameters, registry);
AddEntityForPipingOutput(entity, calculation.Output);
return(entity);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string name = "A";
const string comments = "B";
var calculation = new SemiProbabilisticPipingCalculationScenario
{
Name = name,
Comments =
{
Body = comments
}
};
var registry = new PersistenceRegistry();
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0);
// Assert
TestHelper.AssertAreEqualButNotSame(name, entity.Name);
TestHelper.AssertAreEqualButNotSame(comments, entity.Comments);
}
public void Create_GroupWithChildSemiProbabilisticPipingCalculations_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new SemiProbabilisticPipingCalculationScenario
{
Name = "A"
},
new SemiProbabilisticPipingCalculationScenario
{
Name = "B"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
SemiProbabilisticPipingCalculationEntity[] semiProbabilisticChildCalculationEntities = entity.SemiProbabilisticPipingCalculationEntities.ToArray();
Assert.AreEqual(2, semiProbabilisticChildCalculationEntities.Length);
SemiProbabilisticPipingCalculationEntity childEntity1 = semiProbabilisticChildCalculationEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
SemiProbabilisticPipingCalculationEntity childEntity2 = semiProbabilisticChildCalculationEntities[1];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
}
/// <summary>
/// Read the <see cref="SemiProbabilisticPipingCalculationEntity"/> and use the information to
/// construct a <see cref="SemiProbabilisticPipingCalculationScenario"/>.
/// </summary>
/// <param name="entity">The <see cref="SemiProbabilisticPipingCalculationEntity"/> to create
/// <see cref="SemiProbabilisticPipingCalculationScenario"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="SemiProbabilisticPipingCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
public static SemiProbabilisticPipingCalculationScenario Read(this SemiProbabilisticPipingCalculationEntity entity,
ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new SemiProbabilisticPipingCalculationScenario
{
IsRelevant = Convert.ToBoolean(entity.RelevantForScenario),
Contribution = (RoundedDouble)entity.ScenarioContribution,
Name = entity.Name,
Comments =
{
Body = entity.Comments
}
};
ReadInputParameters(calculation.InputParameters, entity, collector);
ReadCalculationOutputs(calculation, entity);
return(calculation);
}
public void Create_GroupWithChildPipingCalculationsAndChildCalculationGroups_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new CalculationGroup
{
Name = "A"
},
new SemiProbabilisticPipingCalculationScenario
{
Name = "B"
},
new ProbabilisticPipingCalculationScenario
{
Name = "C"
},
new CalculationGroup
{
Name = "D"
},
new SemiProbabilisticPipingCalculationScenario
{
Name = "E"
},
new ProbabilisticPipingCalculationScenario
{
Name = "F"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray();
SemiProbabilisticPipingCalculationEntity[] semiProbabilisticChildCalculationEntities = entity.SemiProbabilisticPipingCalculationEntities.ToArray();
ProbabilisticPipingCalculationEntity[] probabilisticChildCalculationEntities = entity.ProbabilisticPipingCalculationEntities.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual(2, semiProbabilisticChildCalculationEntities.Length);
Assert.AreEqual(2, probabilisticChildCalculationEntities.Length);
CalculationGroupEntity childEntity1 = childGroupEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1);
SemiProbabilisticPipingCalculationEntity childEntity2 = semiProbabilisticChildCalculationEntities[0];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
ProbabilisticPipingCalculationEntity childEntity3 = probabilisticChildCalculationEntities[0];
Assert.AreEqual("C", childEntity3.Name);
Assert.AreEqual(2, childEntity3.Order);
CalculationGroupEntity childEntity4 = childGroupEntities[1];
Assert.AreEqual("D", childEntity4.Name);
Assert.AreEqual(3, childEntity4.Order);
CollectionAssert.IsEmpty(childEntity4.CalculationGroupEntity1);
SemiProbabilisticPipingCalculationEntity childEntity5 = semiProbabilisticChildCalculationEntities[1];
Assert.AreEqual("E", childEntity5.Name);
Assert.AreEqual(4, childEntity5.Order);
ProbabilisticPipingCalculationEntity childEntity6 = probabilisticChildCalculationEntities[1];
Assert.AreEqual("F", childEntity6.Name);
Assert.AreEqual(5, childEntity6.Order);
}
public void Create_SemiProbabilisticPipingCalculationScenarioWithPropertiesSet_ReturnSemiProbabilisticPipingCalculationEntity(
bool isRelevant, bool useAssessmentLevelManualInput, double contribution, string name, string comments,
double exitPoint, double entryPoint, double assessmentLevel, int order, int randomSeed)
{
// Setup
var random = new Random(randomSeed);
var calculation = new SemiProbabilisticPipingCalculationScenario
{
IsRelevant = isRelevant,
Contribution = (RoundedDouble)contribution,
Name = name,
Comments =
{
Body = comments
},
InputParameters =
{
ExitPointL = (RoundedDouble)exitPoint,
EntryPointL = (RoundedDouble)entryPoint,
PhreaticLevelExit =
{
Mean = random.NextRoundedDouble(-9999.9999, 9999.9999),
StandardDeviation = random.NextRoundedDouble(1e-6, 9999.9999)
},
DampingFactorExit =
{
Mean = random.NextRoundedDouble(1e-6, 9999.9999),
StandardDeviation = random.NextRoundedDouble(1e-6, 9999.9999)
},
UseAssessmentLevelManualInput = useAssessmentLevelManualInput,
AssessmentLevel = (RoundedDouble)assessmentLevel
}
};
var registry = new PersistenceRegistry();
// Call
SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, order);
// Assert
Assert.AreEqual(Convert.ToByte(isRelevant), entity.RelevantForScenario);
Assert.AreEqual(calculation.Contribution, entity.ScenarioContribution);
Assert.AreEqual(name, entity.Name);
Assert.AreEqual(comments, entity.Comments);
Assert.AreEqual(exitPoint.ToNaNAsNull(), entity.ExitPointL);
Assert.AreEqual(entryPoint.ToNaNAsNull(), entity.EntryPointL);
SemiProbabilisticPipingInput input = calculation.InputParameters;
Assert.AreEqual(input.PhreaticLevelExit.Mean.Value, entity.PhreaticLevelExitMean);
Assert.AreEqual(input.PhreaticLevelExit.StandardDeviation.Value, entity.PhreaticLevelExitStandardDeviation);
Assert.AreEqual(input.DampingFactorExit.Mean.Value, entity.DampingFactorExitMean);
Assert.AreEqual(input.DampingFactorExit.StandardDeviation.Value, entity.DampingFactorExitStandardDeviation);
Assert.AreEqual(Convert.ToByte(input.UseAssessmentLevelManualInput), entity.UseAssessmentLevelManualInput);
Assert.AreEqual(input.AssessmentLevel.ToNaNAsNull(), entity.AssessmentLevel);
Assert.AreEqual(order, entity.Order);
Assert.AreEqual(0, entity.SemiProbabilisticPipingCalculationEntityId);
Assert.IsNull(entity.CalculationGroupEntity);
Assert.IsNull(entity.SurfaceLineEntity);
Assert.IsNull(entity.PipingStochasticSoilProfileEntity);
Assert.IsNull(entity.HydraulicLocationEntity);
CollectionAssert.IsEmpty(entity.SemiProbabilisticPipingCalculationOutputEntities);
}
private static void ReadInputParameters(SemiProbabilisticPipingInput inputParameters, SemiProbabilisticPipingCalculationEntity entity,
ReadConversionCollector collector)
{
if (entity.SurfaceLineEntity != null)
{
inputParameters.SurfaceLine = entity.SurfaceLineEntity.ReadAsPipingSurfaceLine(collector);
}
inputParameters.UseAssessmentLevelManualInput = Convert.ToBoolean(entity.UseAssessmentLevelManualInput);
inputParameters.AssessmentLevel = (RoundedDouble)entity.AssessmentLevel.ToNullAsNaN();
if (entity.HydraulicLocationEntity != null)
{
inputParameters.HydraulicBoundaryLocation = entity.HydraulicLocationEntity.Read(collector);
}
if (entity.PipingStochasticSoilProfileEntity != null)
{
inputParameters.StochasticSoilModel = entity.PipingStochasticSoilProfileEntity.StochasticSoilModelEntity.ReadAsPipingStochasticSoilModel(collector);
inputParameters.StochasticSoilProfile = entity.PipingStochasticSoilProfileEntity.Read(collector);
}
inputParameters.EntryPointL = (RoundedDouble)entity.EntryPointL.ToNullAsNaN();
inputParameters.ExitPointL = (RoundedDouble)entity.ExitPointL.ToNullAsNaN();
inputParameters.PhreaticLevelExit.Mean = (RoundedDouble)entity.PhreaticLevelExitMean.ToNullAsNaN();
inputParameters.PhreaticLevelExit.StandardDeviation = (RoundedDouble)entity.PhreaticLevelExitStandardDeviation.ToNullAsNaN();
inputParameters.DampingFactorExit.Mean = (RoundedDouble)entity.DampingFactorExitMean.ToNullAsNaN();
inputParameters.DampingFactorExit.StandardDeviation = (RoundedDouble)entity.DampingFactorExitStandardDeviation.ToNullAsNaN();
}
