public void VerifyPMeanIsNotCalculatedIfPDutyCycleAndPMeanHaveDifferentOptionDependency()
{
var pDutyCyc = this.elementDefinition.Parameter.Single(p => p.ParameterType.ShortName == "p_duty_cyc");
pDutyCyc.IsOptionDependent = true;
var option1 = new Option(Guid.NewGuid(), this.assembler.Cache, this.credentials.Uri)
{
Name = "Option 1",
ShortName = "OPT_1",
};
foreach (var parameterValueSet in pDutyCyc.ValueSet)
{
parameterValueSet.ActualOption = option1;
}
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(13, arrayAssembler.NamesArray.GetLength(1));
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 12]);
Assert.AreEqual("-", arrayAssembler.ContentArray[6, 12]);
}
public void VerifyThatAssemblerPopulatesEmptyArrays()
{
var arrayAssembler = new CrossviewArrayAssembler(this.excelRows, new List <Guid>());
var contentArray = arrayAssembler.ContentArray;
// The array contains more rows to make a nice header and spacing
Assert.AreEqual(this.excelRows.Count, contentArray.GetLength(0) - CrossviewSheetConstants.HeaderDepth);
}
public void VerifyThatAssemblerPopulatesArrays()
{
var crossviewSheetRowAssembler = new CrossviewSheetRowAssembler();
crossviewSheetRowAssembler.Assemble(this.iteration, this.elementDefinitions.Select(x => x.Iid));
this.excelRows.AddRange(crossviewSheetRowAssembler.ExcelRows);
var arrayAssembler = new CrossviewArrayAssembler(this.excelRows, this.parameterTypes.Select(x => x.Iid));
var contentArray = arrayAssembler.ContentArray;
// The array contains more rows to make a nice header and spacing
Assert.AreEqual(this.excelRows.Count, contentArray.GetLength(0) - CrossviewSheetConstants.HeaderDepth);
Assert.AreEqual("ElementDefinition_1", contentArray[CrossviewSheetConstants.HeaderDepth, 0]);
Assert.AreEqual("ED_1", contentArray[CrossviewSheetConstants.HeaderDepth, 1]);
}
public void VerifyPMeanIsNotCalculatedIfPMeanIsMissing()
{
this.elementDefinition.Parameter.RemoveAll(p => p.ParameterType.ShortName == "p_mean");
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsFalse(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(12, arrayAssembler.NamesArray.GetLength(1));
}
/// <summary>
/// Collect the information that is to be written to the crossview sheet.
/// </summary>
/// <param name="elementDefinitions">
/// Selected <see cref="ElementDefinition"/>s list.
/// </param>
/// <param name="parameterTypes">
/// Selected <see cref="ParameterType"/>s list.
/// </param>
private void PopulateSheetArrays(IEnumerable <Guid> elementDefinitions, IEnumerable <Guid> parameterTypes)
{
// Instantiate the different rows
var sheetRowAssembler = new CrossviewSheetRowAssembler();
sheetRowAssembler.Assemble(this.iteration, elementDefinitions);
var excelRows = sheetRowAssembler.ExcelRows;
// Use the instantiated rows to populate the excel array
this.crossviewArrayAssember = new CrossviewArrayAssembler(excelRows, parameterTypes);
// Instantiate header
this.headerArrayAssembler = new CrossviewHeaderArrayAssembler(
this.session,
this.iteration,
this.participant,
this.crossviewArrayAssember.ContentArray.GetLength(1));
}
public void VerifyThatAssemblerCalculatesPMeanIfRedundancyTypeIsInternal()
{
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(13, arrayAssembler.ContentArray.GetLength(1));
Assert.AreEqual(@"Crossview_ED_1.p_duty_cyc\PS_1", arrayAssembler.NamesArray[6, 11]);
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 12]);
Assert.IsTrue(double.TryParse(arrayAssembler.ContentArray[6, 12].ToString(), out _));
}
public void VerifyPMeanIsNotCalculatedIfPDutyCycleAndPeanHaveDifferentStateDependency()
{
this.elementDefinition.Parameter.Single(p => p.ParameterType.ShortName == "p_duty_cyc").StateDependence = null;
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(13, arrayAssembler.NamesArray.GetLength(1));
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 12]);
Assert.AreEqual("-", arrayAssembler.ContentArray[6, 12]);
}
public void VerifyPMeanIsNotCalculatedIfRedundancyNIsMissing()
{
var redundancy = this.elementDefinition.Parameter
.Single(p => p.ParameterType.ShortName == "redundancy").ParameterType as CompoundParameterType;
redundancy.Component.Remove(redundancy.Component.Single(c => c.ShortName == "n"));
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(12, arrayAssembler.NamesArray.GetLength(1));
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 11]);
Assert.AreEqual("-", arrayAssembler.ContentArray[6, 11]);
}
public void VerifyThatPMeanIsNotComputedWhenDutyCycleHasInvalidValue()
{
this.elementDefinition.Parameter.RemoveAll(p => p.ParameterType.ShortName == "p_duty_cyc");
this.elementDefinition.Parameter.Add(this.pDutyCycleParameterWithInvalidValue);
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(13, arrayAssembler.ContentArray.GetLength(1));
// indices have to account for parameter [re]ordering
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 11]);
Assert.AreEqual(@"Crossview_ED_1.p_duty_cyc\PS_1", arrayAssembler.NamesArray[6, 12]);
Assert.AreEqual("-", arrayAssembler.ContentArray[6, 11]);
}
public void VerifyThatAssemblerCalculatesPMeanIfRedundancyTypeIsExternal()
{
this.elementDefinition.Parameter.RemoveAll(p => p.ParameterType.ShortName == "redundancy");
this.elementDefinition.Parameter.Add(this.pRedundancyActiveExternalParameter);
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(13, arrayAssembler.ContentArray.GetLength(1));
// indices have to account for parameter [re]ordering
Assert.AreEqual(@"Crossview_ED_1.p_duty_cyc\PS_1", arrayAssembler.NamesArray[6, 7]);
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 8]);
Assert.IsTrue(double.TryParse(arrayAssembler.ContentArray[6, 8].ToString(), out _));
}
public void VerifyPMeanIsNotCalculatedIfRedundancyIsNotCompound()
{
this.elementDefinition.Parameter.Single(p => p.ParameterType.ShortName == "redundancy")
.ParameterType = new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.credentials.Uri)
{
Name = "redundancy",
ShortName = "redundancy"
};
var arrayAssembler = new CrossviewArrayAssembler(
this.excelRows,
this.elementDefinition.Parameter.Select(p => p.ParameterType.Iid));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("redundancy"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_on"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_stby"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_duty_cyc"));
Assert.IsTrue(arrayAssembler.HeaderDictionary.ContainsKey("p_mean"));
Assert.AreEqual(10, arrayAssembler.ContentArray.GetLength(1));
Assert.AreEqual(@"Crossview_ED_1.p_mean\PS_1", arrayAssembler.NamesArray[6, 9]);
Assert.AreEqual("-", arrayAssembler.ContentArray[6, 9]);
}
/// <summary>
/// Calculate mean power parameter value based on multiple parameter values
/// </summary>
/// <param name="crossviewArrayAssembler">
/// The <see cref="CrossviewArrayAssembler"/>
/// </param>
/// <param name="contentRow">
/// The current Excel row values
/// </param>
/// <param name="namesRow">
/// The current Excel row names
/// </param>
/// <param name="parameters">
/// The <see cref="ParameterOrOverrideBase"/>s present on the <see cref="contentRow"/>
/// </param>
internal static void ComputePMean(
CrossviewArrayAssembler crossviewArrayAssembler,
object[] contentRow,
object[] namesRow,
List <ParameterOrOverrideBase> parameters)
{
ParameterOrOverrideBase redundancy = null, pOn = null, pStandBy = null, pDutyCycle = null, pMean = null;
foreach (var parameterOrOverrideBase in parameters)
{
switch (parameterOrOverrideBase.ParameterType.ShortName.ToLowerInvariant())
{
case Redundancy:
redundancy = parameterOrOverrideBase;
break;
case POn:
pOn = parameterOrOverrideBase;
break;
case PStandBy:
pStandBy = parameterOrOverrideBase;
break;
case PDutyCycle:
pDutyCycle = parameterOrOverrideBase;
break;
case PMean:
pMean = parameterOrOverrideBase;
break;
}
}
// ensure all required parameters are present
if (redundancy == null || pOn == null || pStandBy == null || pDutyCycle == null || pMean == null)
{
return;
}
// ensure all required parameters have the same option dependency
if (redundancy.IsOptionDependent != pOn.IsOptionDependent ||
pOn.IsOptionDependent != pStandBy.IsOptionDependent ||
pStandBy.IsOptionDependent != pDutyCycle.IsOptionDependent ||
pDutyCycle.IsOptionDependent != pMean.IsOptionDependent)
{
return;
}
// ensure redundancy, p_on, and p_stby are not state dependent
if (redundancy.StateDependence != null || pOn.StateDependence != null || pStandBy.StateDependence != null)
{
return;
}
// ensure redundancy has required components
if (!(redundancy.ParameterType is CompoundParameterType))
{
return;
}
var compoundRedundancy = (CompoundParameterType)redundancy.ParameterType;
var redundancySchemeComponent = compoundRedundancy.Component
.FirstOrDefault(x => x.ShortName.Equals(RedundancyScheme, StringComparison.InvariantCultureIgnoreCase));
if (redundancySchemeComponent == null)
{
return;
}
var redundancyTypeComponent = compoundRedundancy.Component
.FirstOrDefault(x => x.ShortName.Equals(RedundancyType, StringComparison.InvariantCultureIgnoreCase));
if (redundancyTypeComponent == null)
{
return;
}
var redundancyKComponent = compoundRedundancy.Component
.FirstOrDefault(x => x.ShortName.Equals(RedundancyK, StringComparison.InvariantCultureIgnoreCase));
if (redundancyKComponent == null)
{
return;
}
var redundancyNComponent = compoundRedundancy.Component
.FirstOrDefault(x => x.ShortName.Equals(RedundancyN, StringComparison.InvariantCultureIgnoreCase));
if (redundancyNComponent == null)
{
return;
}
// ensure p_duty_cyc and p_mean are state dependent
if (pDutyCycle.StateDependence == null || pMean.StateDependence == null)
{
return;
}
// ensure p_duty_cyc and p_mean have the same state dependency
if (pDutyCycle.StateDependence != pMean.StateDependence)
{
return;
}
foreach (var option in redundancy.ValueSets.Select(x => x.ActualOption))
{
var redundancyValueSet = redundancy.ValueSets.First(x => x.ActualOption == option) as ParameterValueSetBase;
var pOnValueSet = pOn.ValueSets.First(x => x.ActualOption == option) as ParameterValueSetBase;
var pStandByValueSet = pStandBy.ValueSets.First(x => x.ActualOption == option) as ParameterValueSetBase;
var pDutyCycleValueSets = pDutyCycle.ValueSets.Where(x => x.ActualOption == option);
var pMeanValueSets = pMean.ValueSets.Where(x => x.ActualOption == option);
foreach (var state in pDutyCycleValueSets.Select(x => x.ActualState))
{
var pDutyCycleValueSet = pDutyCycleValueSets.First(x => x.ActualState == state) as ParameterValueSetBase;
var pMeanValueSet = pMeanValueSets.First(x => x.ActualState == state) as ParameterValueSetBase;
var value = ComputePMean(
contentRow[crossviewArrayAssembler.GetContentColumnIndex(redundancyValueSet, redundancySchemeComponent)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(redundancyValueSet, redundancyTypeComponent)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(redundancyValueSet, redundancyKComponent)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(redundancyValueSet, redundancyNComponent)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(pOnValueSet)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(pStandByValueSet)] as string,
contentRow[crossviewArrayAssembler.GetContentColumnIndex(pDutyCycleValueSet)] as string);
if (value == null)
{
continue;
}
var index = crossviewArrayAssembler.GetContentColumnIndex(pMeanValueSet);
contentRow[index] = value;
// highlight only interactible cells
if (namesRow[index] != null)
{
crossviewArrayAssembler.SpecialHighlighting[namesRow[index] as string] = Color.Green;
}
}
}
}
