protected AbstractElement(PerimeterType perimeterType, PerimetersAnalysis perimeters, RiskPlanningVCI elvci, RiskPlanningPDS elpds)
: this(perimeterType, perimeters, elvci)
{
if (elpds == null)
{
throw new InvalidNullArgumentException();
}
pds = elpds;
}
protected AbstractElement(PerimeterType perimeterType, PerimetersAnalysis perimeters) // Not classified
{
Perimeter = perimeterType;
if (perimeters == null)
{
throw new InvalidNullArgumentException();
}
this.perimeters = perimeters;
}
protected AbstractElement(PerimeterType perimeterType, PerimetersAnalysis perimeters, RiskPlanningVCI elvci)
: this(ElementTypes.Classified, perimeterType, perimeters)
{
if (elvci == null)
{
throw new InvalidNullArgumentException();
}
vci = elvci;
}
public Perimeter(PerimeterType perimetertype, double averageVCIC3, double averageVCI, double fractionWithVCI)
{
_perimetertype = perimetertype;
_averageVCIC3 = averageVCIC3;
_averageVCI = averageVCI;
_fractionWithVCI = fractionWithVCI;
}
[InlineData(PerimeterType.AdministrationFinanceAndControl, ElementTypes.Classified, 718.75)] // classified element (absent) with perimeter not covered
public void GetResidualRiskEstimate_DifferentFunctionalPerimeters_ReturnRREstimate(
PerimeterType perimeter, ElementTypes classification, double expectedvci
)
{
Perimeter analysis = perimeters.FindByType(perimeter);
double estimatedVCI = analysis.GetResidualRiskEstimate(classification);
estimatedVCI.Should().Be(expectedvci);
}
public CompleteElement CreateCase()
{
PerimeterType perimeter = SelectPerimeter();
PerimetersAnalysis perimeters = CreatePerimetersAnalysis();
RiskPlanningVCI vci = CreateRPVci(); // vci=750
RiskPlanningPDS pds = CreateRPpds();
return(new CompleteElement(perimeter, perimeters, vci, pds));
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (Title.Length != 0)
{
hash ^= Title.GetHashCode();
}
if (Description.Length != 0)
{
hash ^= Description.GetHashCode();
}
if (createTime_ != null)
{
hash ^= CreateTime.GetHashCode();
}
if (updateTime_ != null)
{
hash ^= UpdateTime.GetHashCode();
}
if (PerimeterType != global::Google.Identity.AccessContextManager.V1.ServicePerimeter.Types.PerimeterType.Regular)
{
hash ^= PerimeterType.GetHashCode();
}
if (status_ != null)
{
hash ^= Status.GetHashCode();
}
if (spec_ != null)
{
hash ^= Spec.GetHashCode();
}
if (UseExplicitDryRunSpec != false)
{
hash ^= UseExplicitDryRunSpec.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public static extern int navigator_invoke_query_set_perimeter(
IntPtr query,
PerimeterType perimeter);
public bool IsTypeOf(PerimeterType perimetertype)
{
return(_perimetertype == perimetertype);
}
public CompleteElement(PerimeterType perimeterType, PerimetersAnalysis perimeters, RiskPlanningVCI vci, RiskPlanningPDS pds) // Classified by default
: base(perimeterType, perimeters, vci, pds)
{
}
public void GetStatus_DifferentFunctionalPerimeters_ExpectedAnalysisStatus(PerimeterType perimeter, AnalysisStatus status)
{
AnalysisStatus result = perimeters.GetStatus(perimeter);
result.Should().Be(status);
}
public AnalysisStatus GetStatus(PerimeterType perimeterType)
{
Perimeter perimeter = FindByType(perimeterType);
return(perimeter?.GetStatus() ?? AnalysisStatus.Missing);
}
private void calculateBaseProperties(IEnumerable <SectionCoordinates> perimeters, PerimeterType perimeterType)
{
//determines if values should be added or subtracked.
var multiplier = perimeterType == PerimeterType.Outer ? 1 : -1;
foreach (var perimeter in perimeters)
{
for (int i = 0; i <= perimeter.Coordinates.Count - 2; i++)
{
double x1, x2, y1, y2;
x1 = perimeter.Coordinates[i].X;
x2 = perimeter.Coordinates[i + 1].X;
y1 = perimeter.Coordinates[i].Y;
y2 = perimeter.Coordinates[i + 1].Y;
area = area + (x1 - x2) * (y2 + y1);
firstMomentOfAreaAxisX = firstMomentOfAreaAxisX + ((x1 - x2) * (y1 * y1 + y1 * y2 + y2 * y2)) * multiplier;
firstMomentOfAreaAxisY = firstMomentOfAreaAxisY + ((y2 - y1) * (x1 * x1 + x1 * x2 + x2 * x2)) * multiplier;
secondMomentOfAreaAxisX = secondMomentOfAreaAxisX + ((x1 - x2) * (y1 * y1 * y1 + y1 * y1 * y2 + y1 * y2 * y2 + y2 * y2 * y2)) * multiplier;
secondMomentOfAreaAxisY = secondMomentOfAreaAxisY + ((y2 - y1) * (x1 * x1 * x1 + x1 * x1 * x2 + x1 * x2 * x2 + x2 * x2 * x2)) * multiplier;
momentOfDeviationAxisXY = momentOfDeviationAxisXY + ((x1 - x2) * (x1 * (3 * y1 * y1 + y2 * y2 + 2 * y1 * y2) + x2 * (3 * y2 * y2 + y1 * y1 + 2 * y1 * y2))) * multiplier;
}
}
}
public AbsentElement(PerimeterType perimeterType, PerimetersAnalysis perimeters)
: base(ElementTypes.Classified, perimeterType, perimeters)
{
}
protected AbstractElement(ElementTypes elclassification, PerimeterType perimeterType, PerimetersAnalysis perimeters) // For classified elements
: this(perimeterType, perimeters)
{
classification = elclassification;
}
public static extern int navigator_invoke_invocation_set_perimeter(
IntPtr invocation,
PerimeterType perimeter);
public NotClassifiedElement(PerimeterType perimeterType, PerimetersAnalysis perimeters)
: base(perimeterType, perimeters)
{
}
public Perimeter FindByType(PerimeterType perimeterType)
{
return(this.Find(e => e.IsTypeOf(perimeterType)));
}
public void Add(PerimeterType perimeterType, double averageVCIC3, double averageVCI, double fractionWithVCI)
{
Perimeter perimeter = new Perimeter(perimeterType, averageVCIC3, averageVCI, fractionWithVCI);
this.Add(perimeter);
}
public IncompleteElement(PerimeterType perimeterType, PerimetersAnalysis perimeters, RiskPlanningVCI elvci) // Classified by default
: base(perimeterType, perimeters, elvci)
{
}
