/// <summary>
/// Creates context menu for a <see cref="ParameterOverride"/> if it is an STEP 3D parameter.
///
/// <seealso cref="IDstHubService.IsSTEPParameterType"/>
/// </summary>
/// <param name="parameter"><see cref="ParameterOverride"/> </param>
private void ProcessParameterContextMenu(ParameterOrOverrideBase parameter)
{
if (!this.dstHubService.IsSTEPParameterType(parameter.ParameterType))
{
return;
}
try
{
IValueSet valueSet = parameter.ValueSets.LastOrDefault();
var valuearray = valueSet.Computed;
CompoundParameterType compound = (CompoundParameterType)parameter.ParameterType;
var name_component = compound.Component.FirstOrDefault(x => x.ShortName == "name");
var source_component = compound.Component.FirstOrDefault(x => x.ShortName == "source");
var part_name = valuearray[name_component.Index];
var part_filereference = valuearray[source_component.Index];
this.fileRevisionId = part_filereference;
this.ContextMenu.Add(new ContextMenuItemViewModel(
$"Download Associated STEP 3D file to \"{part_name}\" {part_filereference}", "",
this.DownloadGuidCommand,
MenuItemKind.Export, ClassKind.NotThing));
}
catch (Exception exception)
{
Logger.Warn(exception, "Ignoring context menue creation for ParameterOrOverride");
}
}
/// <summary>
/// Set the value for this row from the <see cref="ParameterOrOverrideBase"/> and the associated <see cref="ParameterValueSetBase"/>
/// </summary>
/// <param name="parameterOrOveride">The <see cref="ParameterOrOverrideBase"/></param>
/// <param name="valueSet">The <see cref="ParameterValueSetBase"/></param>
/// <param name="index">The Index of the Value to get</param>
public void SetScalarValue(ParameterOrOverrideBase parameterOrOveride, ParameterValueSetBase valueSet, int?index = null)
{
this.Value = index.HasValue && valueSet.Published.Count() > index
? valueSet.Published[index.Value]
: valueSet.Published.FirstOrDefault();
var actualValue = index.HasValue && valueSet.Published.Count() > index
? valueSet.ActualValue[index.Value]
: valueSet.ActualValue.FirstOrDefault();
// propagate values to aid in modelcode updates
this.valueSetIndex = index;
this.valueSet = valueSet;
this.UpdateModelCode();
this.Switch = valueSet.ValueSwitch;
if (this.Value == null || actualValue == null)
{
return;
}
if (this.Value != actualValue)
{
this.IsPublishable = true;
}
if (this.Scale != null)
{
this.Value += " [" + this.Scale.ShortName + "]";
}
}
/// <summary>
/// Adds the publishable <see cref="PublicationParameterOrOverrideRowViewModel"/> row view model to the tree.
/// </summary>
/// <param name="parameter">The <see cref="ParameterOrOverrideBase"/> that this row will belong to.</param>
private void AddPublishableParameterRowViewModel(ParameterOrOverrideBase parameter)
{
var domainRow = this.Domains.SingleOrDefault(vm => vm.Thing == parameter.Owner);
if (domainRow == null)
{
return;
}
// if the row already exists then simply update it
var parameterRow = domainRow.ContainedRows.FirstOrDefault(pr => pr.Thing == parameter);
if (parameterRow != null)
{
((PublicationParameterOrOverrideRowViewModel)parameterRow).SetProperties();
return;
}
// create the row only if it is publishable
parameterRow = new PublicationParameterOrOverrideRowViewModel(parameter, this.Session, domainRow);
// if the domain row has a checkbox, select this one as well.
((PublicationParameterOrOverrideRowViewModel)parameterRow).ToBePublished = domainRow.ToBePublished;
domainRow.ContainedRows.SortedInsert(parameterRow, rowComparer);
}
/// <summary>
/// Initializes a new instance of the <see cref="PublicationParameterOrOverrideRowViewModel"/> class
/// </summary>
/// <param name="parameterOrOverrideBase">
/// The associated <see cref="ParameterOrOverrideBase"/>
/// </param>
/// <param name="session">
/// The associated <see cref="ISession"/>
/// </param>
/// <param name="containerViewModel">
/// The container Row.
/// </param>
public PublicationParameterOrOverrideRowViewModel(ParameterOrOverrideBase parameterOrOverrideBase, ISession session, IRowViewModelBase <Thing> containerViewModel)
: base(parameterOrOverrideBase, session, containerViewModel, false)
{
this.WhenAnyValue(vm => vm.ToBePublished).Subscribe(_ => this.ToBePublishedChanged());
this.IsCheckable = true;
this.SetProperties();
}
/// <summary>
/// Add the listener associated to the <see cref="ParameterOrOverrideBase" />
/// </summary>
/// <param name="parameterOrOverride">The <see cref="ParameterOrOverrideBase" /></param>
private void AddParameterOrOverrideListener(ParameterOrOverrideBase parameterOrOverride)
{
if (this.ParameterBaseListener.ContainsKey(parameterOrOverride))
{
return;
}
Func <ObjectChangedEvent, bool> discriminator =
objectChange => objectChange.EventKind == EventKind.Updated &&
objectChange.ChangedThing.RevisionNumber > this.RevisionNumber;
Action <ObjectChangedEvent> action = x => this.PopulateParameters();
if (this.AllowMessageBusSubscriptions)
{
var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(parameterOrOverride)
.Where(discriminator)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(action);
this.ParameterBaseListener.Add(parameterOrOverride, listener);
}
else
{
var parameterOrOverrideObserver = CDPMessageBus.Current.Listen <ObjectChangedEvent>(typeof(ParameterOrOverrideBase));
this.ParameterBaseListener.Add(parameterOrOverride,
this.MessageBusHandler.GetHandler <ObjectChangedEvent>().RegisterEventHandler(parameterOrOverrideObserver, new ObjectChangedMessageBusEventHandlerSubscription(parameterOrOverride, discriminator, action)));
}
}
/// <summary>
/// Set the value for this row from the <see cref="ParameterOrOverrideBase"/> and the associated <see cref="ParameterValueSetBase"/>
/// </summary>
/// <param name="parameterOrOveride">The <see cref="ParameterOrOverrideBase"/></param>
/// <param name="valueSet">The <see cref="ParameterValueSetBase"/></param>
public void SetScalarValue(ParameterOrOverrideBase parameterOrOveride, ParameterValueSetBase valueSet)
{
// perform checks to see if this is indeed a scalar value
if (valueSet.Published.Count() > 1)
{
logger.Warn("The value set of Parameter or override {0} is marked as Scalar, yet has multiple values.", this.Thing.Iid);
}
this.Value = valueSet.Published.FirstOrDefault();
// handle zero values returned
if (this.Value == null)
{
logger.Warn("The value set of Parameter or override {0} is marked as Scalar, yet has no values.", this.Thing.Iid);
this.Value = "-";
}
if (parameterOrOveride.Scale != null)
{
this.Value += " [" + parameterOrOveride.Scale.ShortName + "]";
}
this.Switch = valueSet.ValueSwitch;
this.ModelCode = valueSet.ModelCode();
}
/// <summary>
/// Checks if creating a <see cref="BinaryRelationship"/> for requirement verification is allowed for these two objects
/// </summary>
/// <param name="parameter">The <see cref="ParameterOrOverrideBase"/></param>
/// <param name="relationalExpression">The <see cref="RelationalExpression"/></param>
/// <returns>True if creation is allowed</returns>
public bool IsCreateBinaryRelationshipForRequirementVerificationAllowed(ParameterOrOverrideBase parameter, RelationalExpression relationalExpression)
{
return((parameter.ParameterType.Iid == relationalExpression.ParameterType.Iid) &&
(!(parameter.ParameterType is QuantityKind) || (parameter.Scale == relationalExpression.Scale)) &&
!relationalExpression.QueryRelationships
.Any(
x => x is BinaryRelationship relationship &&
(relationship.Source.Iid == parameter.Iid)));
}
/// <summary>
/// Update the rows representing the publishable <see cref="ParameterOrOverrideBase"/>
/// </summary>
/// <param name="parameter">The updated <see cref="ParameterOrOverrideBase"/></param>
private void UpdatePublishableParameter(ParameterOrOverrideBase parameter)
{
if (parameter.CanBePublished)
{
this.AddPublishableParameterRowViewModel(parameter);
}
else
{
this.RemovePublishableParameterRowViewModel(parameter);
}
}
/// <summary>
/// Updates the <paramref name="elementRow"/> children with the <paramref name="parameterOrOverrideBase"/>
/// </summary>
/// <typeparam name="TThing">The precise type of <see cref="ElementBase"/></typeparam>
/// <typeparam name="TRow">The type of <paramref name="elementRow"/></typeparam>
/// <param name="parameterOrOverrideBase">The <see cref="ParameterOrOverrideBase"/></param>
/// <param name="oldElement">The old <see cref="ElementBase"/> to be updated</param>
/// <param name="elementRow">The row to perform on the update</param>
private void UpdateRow <TThing, TRow>(ParameterOrOverrideBase parameterOrOverrideBase, TThing oldElement, TRow elementRow)
where TRow : ElementBaseRowViewModel <TThing> where TThing : ElementBase
{
var updatedElement = (TThing)oldElement?.Clone(true);
this.AddOrReplaceParameter(updatedElement, parameterOrOverrideBase);
CDPMessageBus.Current.SendMessage(new HighlightEvent(elementRow.Thing), elementRow.Thing);
elementRow.UpdateThing(updatedElement);
elementRow.UpdateChildren();
}
private void RegisterBinaryRelationShip(ParameterOrOverrideBase parameter, RelationalExpression expression)
{
var relationShip = new BinaryRelationship(Guid.NewGuid(), null, null)
{
Source = parameter,
Target = expression
};
expression.Relationships.Add(relationShip);
relationShip.Source.Relationships.Add(relationShip);
relationShip.Target.Relationships.Add(relationShip);
this.iteration.Relationship.Add(relationShip);
}
/// <summary>
/// Add the listener associated to the <see cref="ParameterOrOverrideBase"/>
/// </summary>
/// <param name="parameterOrOverride">The <see cref="ParameterOrOverrideBase"/></param>
private void AddParameterOrOverrideListener(ParameterOrOverrideBase parameterOrOverride)
{
if (this.ParameterBaseListener.ContainsKey(parameterOrOverride))
{
return;
}
var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(parameterOrOverride)
.Where(objectChange => objectChange.EventKind == EventKind.Updated && objectChange.ChangedThing.RevisionNumber > this.RevisionNumber)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => this.PopulateParameters());
this.ParameterBaseListener.Add(parameterOrOverride, listener);
}
private void SetValueSet(ParameterSubscription subscription, ParameterOrOverrideBase param, IReadOnlyList <string> values)
{
var i = 0;
foreach (var parameterValueSet in param.ValueSets)
{
var valueset = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.cache, this.uri)
{
SubscribedValueSet = (ParameterValueSetBase)parameterValueSet
};
this.SetValueSet(valueset, values[i]);
subscription.ValueSet.Add(valueset);
i++;
}
}
/// <summary>
/// Removes a publishable parameter row view-model if the <see cref="ParameterOrOverrideBase" /> is no longer publishable.
/// </summary>
/// <param name="parameter">The parameter that is no longer publishable.</param>
private void RemovePublishableParameterRowViewModel(ParameterOrOverrideBase parameter)
{
var domainRow = this.Domains.SingleOrDefault(vm => vm.Thing == parameter.Owner);
if (domainRow == null)
{
return;
}
var parameterRow = domainRow.ContainedRows.FirstOrDefault(pr => pr.Thing == parameter);
if (parameterRow != null)
{
domainRow.ContainedRows.RemoveAndDispose(parameterRow);
}
}
/// <summary>
/// Creates a <see cref="NestedParameter"/> based on the provided <see cref="ParameterOrOverrideBase"/> and <see cref="ParameterValueSetBase"/>
/// </summary>
/// <param name="parameter">
/// The <see cref="ParameterOrOverrideBase"/> that contains the <see cref="ParameterValueSetBase"/> based on which the
/// <see cref="NestedParameter"/> is created.
/// </param>
/// <param name="component">
/// The <see cref="ParameterTypeComponent"/> that this <see cref="NestedParameter"/> is associated to. This may be null in case the <see cref="ParameterType"/>
/// of the associated <see cref="Parameter"/> is a <see cref="ScalarParameterType"/>.
/// </param>
/// <param name="valueSet">
/// The <see cref="ParameterValueSetBase"/> that provides the reference to the <see cref="ActualFiniteState"/> and values
/// to create the <see cref="NestedParameter"/>
/// </param>
/// <param name="option">
/// The <see cref="Option"/> for which the <see cref="NestedParameter"/> is created.
/// </param>
/// <returns>
/// An instance of a non-volatile <see cref="NestedParameter"/>
/// </returns>
private NestedParameter CreatedNestedParameter(ParameterOrOverrideBase parameter, ParameterTypeComponent component, ParameterValueSetBase valueSet, Option option)
{
var componentIndex = component == null ? 0 : component.Index;
var actualValue = valueSet.ActualValue[componentIndex];
var formula = valueSet.Formula[componentIndex];
var nestedParameter = new NestedParameter(Guid.NewGuid(), parameter.Cache, parameter.IDalUri)
{
IsVolatile = true,
AssociatedParameter = parameter,
Owner = parameter.Owner,
Component = component,
ActualState = valueSet.ActualState,
ActualValue = actualValue,
Formula = formula,
ValueSet = valueSet,
Option = option
};
return(nestedParameter);
}
/// <summary>
/// Updates the <see cref="Domains"/> of the parameter in case the <see cref="ParameterOrOverrideBase.Owner"/> that contains Parameter changes.
/// </summary>
/// <param name="parameterOrOverrideBase">The <see cref="ParameterOrOverrideBase"/> to relocate or remove</param>
private void RelocateParameterRowViewModel(ParameterOrOverrideBase parameterOrOverrideBase)
{
// In case the owner has changed check if there are other domains that contain that parameter.
var oldOwners = this.Domains.Where(d => d.ContainedRows.Any(p => p.Thing == parameterOrOverrideBase) && d.Thing != parameterOrOverrideBase.Owner);
foreach (var owner in oldOwners)
{
var row = owner.ContainedRows.FirstOrDefault(pr => pr.Thing == parameterOrOverrideBase);
if (row != null)
{
owner.ContainedRows.Remove(row);
row.Dispose();
}
}
if (!parameterOrOverrideBase.CanBePublished)
{
return;
}
var domainRow = this.Domains.SingleOrDefault(vm => vm.Thing == parameterOrOverrideBase.Owner);
if (domainRow == null)
{
return;
}
var parameterRow = domainRow.ContainedRows.FirstOrDefault(pr => pr.Thing == parameterOrOverrideBase);
if (parameterRow == null)
{
parameterRow = new PublicationParameterOrOverrideRowViewModel(parameterOrOverrideBase, this.Session, domainRow);
// if the domain row has a checkbox, select this one as well.
((PublicationParameterOrOverrideRowViewModel)parameterRow).ToBePublished = domainRow.ToBePublished;
domainRow.ContainedRows.SortedInsert(parameterRow, rowComparer);
}
}
/// <summary>
/// Adds or replace the <paramref name="parameterOrOverride"/> on the <paramref name="updatedElement"/>
/// </summary>
/// <param name="updatedElement">The <see cref="ElementBase"/></param>
/// <param name="parameterOrOverride">The <see cref="ParameterOrOverrideBase"/></param>
private void AddOrReplaceParameter(ElementBase updatedElement, ParameterOrOverrideBase parameterOrOverride)
{
if (updatedElement is ElementDefinition elementDefinition)
{
if (elementDefinition.Parameter.FirstOrDefault(p => p.ParameterType.Iid == parameterOrOverride.ParameterType.Iid)
is { } parameter)
{
elementDefinition.Parameter.Remove(parameter);
}
elementDefinition.Parameter.Add((Parameter)parameterOrOverride);
}
else if (updatedElement is ElementUsage elementUsage)
{
if (parameterOrOverride is Parameter elementParameter)
{
if (elementUsage.ElementDefinition.Parameter.FirstOrDefault(p => p.ParameterType.Iid == parameterOrOverride.ParameterType.Iid)
is { } parameter)
{
elementUsage.ElementDefinition.Parameter.Remove(parameter);
}
elementUsage.ElementDefinition.Parameter.Add(elementParameter);
}
else if (parameterOrOverride is ParameterOverride parameterOverride)
{
if (elementUsage.ParameterOverride.FirstOrDefault(p => p.ParameterType.Iid == parameterOrOverride.ParameterType.Iid)
is { } parameter)
{
elementUsage.ParameterOverride.Remove(parameter);
}
elementUsage.ParameterOverride.Add(parameterOverride);
}
}
}
/// <summary>
/// Process the <see cref="ParameterValueSet"/> .
/// </summary>
/// <param name="parameterValueSet">
/// The <see cref="ParameterValueSetBase"/> to be processed.
/// </param>
/// <param name="parameterOrOverrideBase">
/// The <see cref="ParameterOrOverrideBase"/> the <see cref="ParameterValueSetBase"/ belongs to.
/// </param>
/// <param name="componentIndex">
/// The index of the <see cref="ParameterTypeComponent"/>.
/// </param>
/// <param name="computedValue">
/// The manual value of the <see cref="ParameterValueSet"/>.
/// </param>
/// <param name="processedValueSets">
/// A <see cref="Dictionary{Guid,ProcessedValueSet}"/> of ProcessedValueSe that capture the updated <see cref="Thing"/>s with its value validation result
/// </param>
/// <param name="provider">
/// The <see cref="IFormatProvider"/> used to validate.
/// </param>
/// <param name="validationErrorText">
/// <see cref="String"/> that holds the validation error text.
/// </param>
/// <returns>
/// The added or changed <see cref="ProcessedValueSet"/>
/// </returns>
private ProcessedValueSet ProcessValueSet(ParameterValueSetBase parameterValueSet, ParameterOrOverrideBase parameterOrOverrideBase, int componentIndex, string computedValue, ref Dictionary <Guid, ProcessedValueSet> processedValueSets, IFormatProvider provider, out string validationErrorText)
{
var validationResult = ValidationResultKind.InConclusive;
var switchKind = parameterValueSet.ValueSwitch;
var measurementScale = parameterOrOverrideBase.Scale;
var parameterType = parameterOrOverrideBase.ParameterType;
validationErrorText = string.Empty;
if (parameterType != null)
{
if (ValueSetConverter.TryParseDouble(computedValue, parameterType, out var convertedComputedValue))
{
computedValue = convertedComputedValue.ToString(CultureInfo.InvariantCulture);
}
computedValue = computedValue?.ToValueSetObject(parameterType).ToValueSetString(parameterType) ?? parameterValueSet.Computed[componentIndex];
var validManualValue = parameterType.Validate(computedValue, measurementScale, provider);
if (validManualValue.ResultKind > validationResult)
{
validationResult = validManualValue.ResultKind;
validationErrorText = validManualValue.Message;
}
}
var valueSetExists = processedValueSets.TryGetValue(parameterValueSet.Iid, out var processedValueSet);
if (!valueSetExists)
{
processedValueSet = new ProcessedValueSet(parameterValueSet, validationResult);
}
if (processedValueSet.IsDirty(componentIndex, parameterType, switchKind, parameterValueSet.Manual[componentIndex], computedValue, parameterValueSet.Reference[componentIndex], computedValue, out var valueSetValues))
{
processedValueSet.UpdateClone(valueSetValues);
if (!valueSetExists)
{
processedValueSets.Add(parameterValueSet.Iid, processedValueSet);
}
}
return(processedValueSet);
}
/// <summary>
/// Method for creating a <see cref="BinaryRelationship"/> for requirement verification between a <see cref="ParameterOrOverrideBase"/> and a <see cref="RelationalExpression"/>.
/// </summary>
/// <param name="session">The <see cref="Session"/> for which the <see cref="BinaryRelationship"/> will be created</param>
/// <param name="iteration">The <see cref="Iteration"/> for which the <see cref="BinaryRelationship"/> will be created</param>
/// <param name="parameter">The <see cref="ParameterOrOverrideBase"/> that acts as the source of the <see cref="BinaryRelationship"/></param>
/// <param name="relationalExpression">The <see cref="RelationalExpression"/> that acts as the target of the <see cref="BinaryRelationship"/></param>
/// <returns>An awaitable <see cref="Task"/></returns>
public async Task CreateBinaryRelationshipForRequirementVerification(ISession session, Iteration iteration, ParameterOrOverrideBase parameter, RelationalExpression relationalExpression)
{
session.OpenIterations.TryGetValue(iteration, out var tuple);
var binaryRelationship = new BinaryRelationship(Guid.NewGuid(), null, null)
{
Owner = tuple?.Item1
};
var transaction = new ThingTransaction(TransactionContextResolver.ResolveContext(relationalExpression));
binaryRelationship.Container = iteration;
binaryRelationship.Source = parameter;
binaryRelationship.Target = relationalExpression;
var iterationClone = iteration.Clone(false);
iterationClone.Relationship.Add(binaryRelationship);
transaction.CreateOrUpdate(iterationClone);
transaction.Create(binaryRelationship);
try
{
var operationContainer = transaction.FinalizeTransaction();
await session.Write(operationContainer);
}
catch (Exception ex)
{
LogManager.GetLogger(typeof(Iteration).FullName).Error("The inline update operation failed: {0}", ex.Message);
}
}
/// <summary>
/// Performs the drop operation when the payload is a <see cref="RelationalExpression"/>
/// </summary>
/// <param name="parameter">
/// The <see cref="ParameterOrOverrideBase"/>
/// </param>
/// <param name="expression">
/// The <see cref="RelationalExpression"/>
/// </param>
private async Task Drop(ParameterOrOverrideBase parameter, RelationalExpression expression)
{
await this.CreateBinaryRelationship(parameter, expression);
}
/// <summary>
/// Method for creating a <see cref="BinaryRelationship"/> between a <see cref="ParameterOrOverrideBase"/> and a <see cref="RelationalExpression"/>.
/// </summary>
/// <param name="session">The <see cref="Session"/> for which the <see cref="BinaryRelationship"/> will be created</param>
/// <param name="iteration">The <see cref="Iteration"/> for which the <see cref="BinaryRelationship"/> will be created</param>
/// <param name="parameter">The <see cref="ParameterOrOverrideBase"/> that acts as the source of the <see cref="BinaryRelationship"/></param>
/// <param name="relationalExpression">The <see cref="RelationalExpression"/> that acts as the target of the <see cref="BinaryRelationship"/></param>
/// <returns>An awaitable <see cref="Task"/></returns>
public Task CreateBinaryRelationshipForRequirementVerification(ISession session, Iteration iteration, ParameterOrOverrideBase parameter, RelationalExpression relationalExpression)
{
throw new Exception("The Binary Relationship could not be created");
}
/// <summary>
/// Checks if creating a <see cref="BinaryRelationship"/> is allowed for these two objects
/// </summary>
/// <param name="parameter">The <see cref="ParameterOrOverrideBase"/></param>
/// <param name="relationalExpression">The <see cref="RelationalExpression"/></param>
/// <returns>True if creation is allowed</returns>
public bool IsCreateBinaryRelationshipForRequirementVerificationAllowed(ParameterOrOverrideBase parameter, RelationalExpression relationalExpression)
{
return(false);
}
/// <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;
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IterationTrackParameter"/> class.
/// </summary>
/// <param name="parameterOrOverride">The <see cref="ParameterOrOverrideBase"/> that is used to construct this <see cref="IterationTrackParameter"/></param>
public IterationTrackParameter(ParameterOrOverrideBase parameterOrOverride)
{
this.ParameterOrOverride = parameterOrOverride;
this.ModelCode = parameterOrOverride?.ModelCode() ?? "";
this.UnitSymbol = parameterOrOverride?.Scale?.UserFriendlyShortName ?? "-";
}
