public void TestSimEvidenceSourceReferenceRoundTrip()
{
// arrange
var evidenceSources = Range(1, 5, 2).Map(id =>
new SimEvidenceSource(
id,
$"name{id:0000}",
$"desc{id:0000}",
toSet(Range(id, id).Map(s => $"subject{s:0000}")),
$"refName{id:0000}",
$"refHash{id:0000}"
)
)
.ToArr();
var mockEvidence = new Mock <ISimEvidence>();
mockEvidence.Setup(me => me.EvidenceSources).Returns(evidenceSources);
SimEvidenceSource expected = evidenceSources.Skip(1).Take(1).Single();
ISimEvidence evidence = mockEvidence.Object;
// act
var reference = expected.GetReference();
var actual = evidence.GetEvidenceSource(reference);
// assert
Assert.AreEqual(expected, actual);
}
public static string GetReference(this ISimEvidence evidence, SimObservations observations)
{
var evidenceSource = evidence.EvidenceSources
.Find(es => es.ID == observations.EvidenceSourceID)
.AssertSome();
return($"{evidenceSource.GetReference()}/{observations.ID}/{observations.Subject}/{observations.RefName}");
}
internal EstimationDesigns(string pathToEstimationDesignsDirectory, ISimEvidence evidence)
{
_pathToEstimationDesignsDirectory = pathToEstimationDesignsDirectory;
_evidence = evidence;
Directory.CreateDirectory(_pathToEstimationDesignsDirectory);
LoadDesignDigests();
}
private static void SaveDesign(
DateTime createdOn,
Arr <ModelParameter> priors,
Arr <ModelOutput> outputs,
Arr <SimObservations> observations,
int iterations,
int burnIn,
int chains,
double?targetAcceptRate,
bool useApproximation,
string pathToEstimationDesignDirectory,
ISimEvidence evidence
)
{
RequireDirectory(pathToEstimationDesignDirectory);
var dto = new _EstimationDesignDTO
{
CreatedOn = createdOn.ToDirectoryName(),
Priors = priors
.Map(dp => new _PriorDTO {
Name = dp.Name, Distribution = dp.Distribution.ToString()
})
.ToArray(),
Outputs = outputs
.Map(@do => new _OutputDTO {
Name = @do.Name, ErrorModel = @do.ErrorModel.ToString()
})
.ToArray(),
ObservationsReferences = observations
.Map(o => evidence.GetReference(o))
.ToArray(),
Iterations = iterations,
BurnIn = burnIn,
Chains = chains,
TargetAcceptRate = targetAcceptRate,
UseApproximation = useApproximation
};
var pathToDesign = Combine(pathToEstimationDesignDirectory, DESIGN_FILE_NAME);
try
{
Toml.WriteFile(dto, pathToDesign);
}
catch (Exception ex)
{
var message = $"Failed to save estimation design to {pathToDesign}";
Log.Error(ex, message);
throw new Exception(message);
}
}
public SimSharedStateBuilder(
ISimSharedState sharedState,
Simulation simulation,
ISimEvidence evidence,
SimSharedStateBuild buildType
)
{
_sharedState = sharedState;
_simulation = simulation;
_evidence = evidence;
BuildType = buildType;
}
public void TestSimObservationsReferenceRoundTrip()
{
// arrange
var evidenceSources = Range(1, 5, 2).Map(id =>
new SimEvidenceSource(
100 + id,
$"name{id:0000}",
$"desc{id:0000}",
toSet(Range(id, id).Map(s => $"subject{s:0000}")),
$"refName{id:0000}",
$"refHash{id:0000}"
)
)
.ToArr();
var observations = Range(1, 5, 2)
.Map(
id => new SimObservations(
10 + id,
100 + id,
$"subjectX",
$"refName{id:0000}",
Array(1d, 2, 3),
Array(4d, 5, 6)
)
)
.ToArr();
var observationsSet = new SimObservationsSet(observations.Head().Subject, observations);
var mockEvidence = new Mock <ISimEvidence>();
mockEvidence.Setup(me => me.EvidenceSources).Returns(evidenceSources);
mockEvidence.Setup(me => me.GetObservationSet(It.Is <string>(s => s == "subjectX"))).Returns(observationsSet);
ISimEvidence evidence = mockEvidence.Object;
SimEvidenceSource evidenceSource = evidenceSources.Skip(1).Take(1).Single();
SimObservations expected = observations.Skip(1).Take(1).Single();
// act
var reference = evidence.GetReference(expected);
var actual = evidence.GetObservations(reference);
// assert
Assert.AreEqual(expected, actual);
}
internal static ModuleState LoadOrCreate(
Simulation simulation,
ISimEvidence evidence,
IAppService appService,
EstimationDesigns estimationDesigns
)
{
var maybeDTO = simulation.LoadPrivateData <_ModuleStateDTO>(
nameof(Estimation),
nameof(ViewModel),
nameof(ModuleState)
);
return(maybeDTO.Match(
dto => new ModuleState(dto, evidence, appService, estimationDesigns),
() => new ModuleState(evidence, appService, estimationDesigns)
));
}
public static void Save(ModuleState instance, Simulation simulation, ISimEvidence evidence)
{
simulation.SavePrivateData(
new _ModuleStateDTO
{
SelectedObservationsReferences = instance.SelectedObservations
.Map(o => evidence.GetReference(o))
.ToArray(),
SelectedSubject = instance.SelectedObservationsSet
.MatchUnsafe <string?>(os => os.Subject, () => default),
SelectedEvidenceSourceReference = instance.SelectedEvidenceSource
.MatchUnsafe <string?>(es => es.GetReference(), () => default),
AutoApplyParameterSharedState = instance.AutoApplyParameterSharedState,
AutoShareParameterSharedState = instance.AutoShareParameterSharedState,
AutoApplyElementSharedState = instance.AutoApplyElementSharedState,
AutoShareElementSharedState = instance.AutoShareElementSharedState,
AutoApplyObservationsSharedState = instance.AutoApplyObservationsSharedState,
AutoShareObservationsSharedState = instance.AutoShareObservationsSharedState
},
public static Option <SimEvidenceSource> GetEvidenceSource(this ISimEvidence evidence, string reference)
{
try
{
var parts = reference.Split('/');
RequireTrue(parts.Length == 3 || parts.Length == 6);
RequireTrue(int.TryParse(parts[0], out int evidenceSourceID));
var evidenceSourceRefName = parts[1];
RequireTrue(evidenceSourceRefName.IsAString());
var evidenceSourceRefHash = parts[2];
RequireTrue(evidenceSourceRefHash.IsAString());
return(evidence.EvidenceSources
.Find(es => es.ID == evidenceSourceID &&
es.RefName == evidenceSourceRefName &&
es.RefHash == evidenceSourceRefHash
));
}
catch (Exception ex)
{
Log.Error(ex, $"Invalid evidence source reference: {reference}");
return(None);
}
}
public static Option <SimObservations> GetObservations(this ISimEvidence evidence, string reference)
{
try
{
var parts = reference.Split('/');
RequireTrue(parts.Length == 6);
Option <SimObservations> SomeEvidenceSource(SimEvidenceSource es)
{
RequireTrue(int.TryParse(parts[3], out int observationsID));
var subject = parts[4];
RequireTrue(subject.IsAString());
var observationsRefName = parts[5];
RequireTrue(observationsRefName.IsAString());
var observationsSet = evidence.GetObservationSet(subject);
return(observationsSet.Observations.Find(
o => o.ID == observationsID &&
o.RefName == observationsRefName &&
o.EvidenceSourceID == es.ID
));
}
return(evidence
.GetEvidenceSource(reference)
.Match(SomeEvidenceSource, NoneOf <SimObservations>));
}
catch (Exception ex)
{
Log.Error(ex, $"Invalid observations reference: {reference}");
return(None);
}
}
internal DepVarConfigViewModel(
SimOutput output,
ISimEvidence evidence,
IAppService appService,
DepVarConfigState depVarConfigState
)
{
RequireNotNull(output);
RequireTrue(output.SimValues.Count > 0);
RequireNotNull(evidence);
RequireNotNull(depVarConfigState);
var elements = output.DependentVariables;
RequireFalse(elements.IsEmpty);
RequireTrue(
depVarConfigState.SelectedElementName.IsntAString() ||
elements.Exists(e => e.Name == depVarConfigState.SelectedElementName)
);
_elements = elements;
_evidence = evidence;
_depVarConfigState = depVarConfigState;
ToggleView = ReactiveCommand.Create(HandleToggleView);
_selectElement = ReactiveCommand.Create <ISelectableItemViewModel>(HandleSelectElement);
_selectSupplementaryElement = ReactiveCommand.Create <ISelectableItemViewModel>(HandleSelectSupplementaryElement);
_selectObservations = ReactiveCommand.Create <ISelectableItemViewModel>(HandleSelectObservations);
var elementViewModels = elements
.Map(e =>
new SelectableItemViewModel <SimElement>(
e,
e.GetFQName(),
e.Name.ToUpperInvariant(),
_selectElement,
false
)
)
.OrderBy(vm => vm.SortKey);
_elementViewModels = elementViewModels.ToArr();
depVarConfigState.SelectedElementName ??= elementViewModels.First().Item.Name;
_selectedElement = elementViewModels.Single(e => e.Item.Name == depVarConfigState.SelectedElementName);
var partitioned = elementViewModels.Select(
e => e == _selectedElement
? (None, None)
: depVarConfigState.MRUElementNames.Exists(n => n == e.Item.Name)
? (MRU: Some(e), LRU: Option <SelectableItemViewModel <SimElement> > .None)
: (MRU: None, LRU: Some(e))
);
MRUElements = new ObservableCollection <ISelectableItemViewModel>(partitioned.Choose(t => t.MRU));
LRUElements = new ObservableCollection <ISelectableItemViewModel>(partitioned.Choose(t => t.LRU));
_isScaleLogarithmic = depVarConfigState.IsScaleLogarithmic;
InsetOptions = Array("(none)") + _elementViewModels.Map(vm => vm.Item.Name);
SelectedInsetOption = depVarConfigState.SelectedInsetElementName.IsAString()
? InsetOptions.FindIndex(io => io == depVarConfigState.SelectedElementName) + 1
: 0;
PopulateSupplementaryElements();
PopulateObservations();
_reactiveSafeInvoke = appService.GetReactiveSafeInvoke();
_subscriptions = new CompositeDisposable(
evidence.ObservationsChanges.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <(Arr <SimObservations>, ObservableQualifier)>(
ObserveEvidenceObservationChange
)
),
depVarConfigState
.ObservableForProperty(s => s.SelectedElementName)
.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(ObserveStateSelectedElementName)
),
depVarConfigState
.ObservableForProperty(s => s.ObservationsReferences)
.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(ObserveStateObservationsReferences)
),
this
.ObservableForProperty(vm => vm.IsScaleLogarithmic)
.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(ObserveIsScaleLogarithmic)
),
this
.ObservableForProperty(vm => vm.SelectedInsetOption)
.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(ObserveSelectedInsetOption)
)
);
}
public static bool IsSubject(this ISimEvidence evidence, [NotNullWhen(true)] string?subject) => subject.IsAString() && evidence.Subjects.Contains(subject);
private ModuleState(ISimEvidence evidence, IAppService appService, EstimationDesigns estimationDesigns)
: this(new _ModuleStateDTO(), evidence, appService, estimationDesigns)
{
}
private ModuleState(
_ModuleStateDTO dto,
ISimEvidence evidence,
IAppService appService,
EstimationDesigns estimationDesigns
)
{
_estimationDesigns = estimationDesigns;
PriorsState.SelectedPrior = dto.PriorsState?.SelectedPrior;
LikelihoodState.SelectedOutput = dto.LikelihoodState?.SelectedOutput;
DesignState.Iterations = dto.DesignState?.Iterations;
DesignState.BurnIn = dto.DesignState?.BurnIn;
DesignState.Chains = dto.DesignState?.Chains;
SimulationState.SelectedParameter = dto.SimulationState?.SelectedParameter;
if (!dto.PriorStates.IsNullOrEmpty())
{
_priorStates = dto.PriorStates
.Select(ps =>
{
var name = ps.Name.AssertNotNull();
var distributionType = Enum.TryParse(ps.DistributionType, out DistributionType dt) ? dt : DistributionType.None;
var distributionStates = Distribution.DeserializeDistributions(ps.DistributionStates.AssertNotNull());
var isSelected = ps.IsSelected;
return(new ParameterState(name, distributionType, distributionStates, isSelected));
})
.ToArr();
}
if (!dto.OutputStates.IsNullOrEmpty())
{
_outputStates = dto.OutputStates
.Select(os =>
{
var name = os.Name.AssertNotNull();
var errorModelType = Enum.TryParse(os.ErrorModelType, out ErrorModelType emt) ? emt : ErrorModelType.None;
var errorModelStates = ErrorModel.DeserializeErrorModels(os.ErrorModelStates.AssertNotNull());
var isSelected = os.IsSelected;
return(new OutputState(name, errorModelType, errorModelStates, isSelected));
})
.ToArr();
}
_selectedObservations = dto.SelectedObservationsReferences.IsNullOrEmpty()
? default
: dto.SelectedObservationsReferences
.Select(r => evidence.GetObservations(r))
.Somes()
.ToArr();
if (dto.EstimationDesign.IsAString())
{
try
{
var createdOn = dto.EstimationDesign.FromDirectoryName();
EstimationDesign = estimationDesigns.Load(createdOn);
var pathToEstimationDesign = estimationDesigns.GetPathToEstimationDesign(EstimationDesign);
ChainStates = ChainState.Load(pathToEstimationDesign);
PosteriorState = PosteriorState.Load(pathToEstimationDesign);
}
catch (Exception) { /* logged elsewhere */ }
}
RootExportDirectory = dto.RootExportDirectory;
OpenAfterExport = dto.OpenAfterExport;
_autoApplyParameterSharedState = dto.AutoApplyParameterSharedState;
_autoShareParameterSharedState = dto.AutoShareParameterSharedState;
_autoApplyElementSharedState = dto.AutoApplyElementSharedState;
_autoShareElementSharedState = dto.AutoShareElementSharedState;
_autoApplyObservationsSharedState = dto.AutoApplyObservationsSharedState;
_autoShareObservationsSharedState = dto.AutoShareObservationsSharedState;
_reactiveSafeInvoke = appService.GetReactiveSafeInvoke();
_subscriptions = new CompositeDisposable(
evidence.ObservationsChanges.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <(Arr <SimObservations> Observations, ObservableQualifier ObservableQualifier)>(
ObserveEvidenceObservationsChanges
)
)
);
}
internal static void Save(ModuleState instance, Simulation simulation, ISimEvidence evidence)
{
simulation.SavePrivateData(
new _ModuleStateDTO
{
PriorsState = new _PriorsStateDTO
{
SelectedPrior = instance.PriorsState.SelectedPrior
},
LikelihoodState = new _LikelihoodStateDTO
{
SelectedOutput = instance.LikelihoodState.SelectedOutput
},
DesignState = new _DesignStateDTO
{
Iterations = instance.DesignState.Iterations,
BurnIn = instance.DesignState.BurnIn,
Chains = instance.DesignState.Chains
},
SimulationState = new _SimulationStateDTO
{
SelectedParameter = instance.SimulationState.SelectedParameter
},
PriorStates = instance.PriorStates
.Map(ps => new _PriorStateDTO
{
Name = ps.Name,
DistributionType = ps.DistributionType.ToString(),
DistributionStates = Distribution.SerializeDistributions(ps.Distributions),
IsSelected = ps.IsSelected
})
.ToArray(),
OutputStates = instance.OutputStates
.Map(os => new _OutputStateDTO
{
Name = os.Name,
ErrorModelType = os.ErrorModelType.ToString(),
ErrorModelStates = ErrorModel.SerializeErrorModels(os.ErrorModels),
IsSelected = os.IsSelected
})
.ToArray(),
SelectedObservationsReferences = instance.SelectedObservations
.Map(o => evidence.GetReference(o))
.ToArray(),
EstimationDesign = instance.EstimationDesign?.CreatedOn.ToDirectoryName(),
RootExportDirectory = instance.RootExportDirectory,
OpenAfterExport = instance.OpenAfterExport,
AutoApplyParameterSharedState = instance.AutoApplyParameterSharedState,
AutoShareParameterSharedState = instance.AutoShareParameterSharedState,
AutoApplyElementSharedState = instance.AutoApplyElementSharedState,
AutoShareElementSharedState = instance.AutoShareElementSharedState,
AutoApplyObservationsSharedState = instance.AutoApplyObservationsSharedState,
AutoShareObservationsSharedState = instance.AutoShareObservationsSharedState
},
nameof(Estimation),
nameof(ViewModel),
nameof(ModuleState)
);
}
public static string GetFQObservationsName(this ISimEvidence evidence, SimObservations observations) => observations.GetFQObservationsName(evidence.GetEvidenceSource(observations.EvidenceSourceID));
internal static void UpdateEstimationDesign(EstimationDesign instance, string pathToEstimationDesignsDirectory, ISimEvidence evidence)
{
RequireDirectory(pathToEstimationDesignsDirectory);
var pathToEstimationDesignDirectory = GetPathToEstimationDesign(instance, pathToEstimationDesignsDirectory);
RequireDirectory(pathToEstimationDesignDirectory);
SaveDesign(
instance.CreatedOn,
instance.Priors,
instance.Outputs,
instance.Observations,
instance.Iterations,
instance.BurnIn,
instance.Chains,
instance.TargetAcceptRate,
instance.UseApproximation,
pathToEstimationDesignDirectory,
evidence
);
}
internal static EstimationDesign LoadEstimationDesign(string pathToEstimationDesignsDirectory, DateTime createdOn, ISimEvidence evidence)
{
var pathToEstimationDesignDirectory = GetPathToEstimationDesign(createdOn, pathToEstimationDesignsDirectory);
var pathToDesign = Combine(pathToEstimationDesignDirectory, DESIGN_FILE_NAME);
try
{
var dto = Toml.ReadFile <_EstimationDesignDTO>(pathToDesign);
RequireNotNull(dto.Priors);
var priors = dto.Priors
.Select(dp => new ModelParameter(
dp.Name.AssertNotNull(),
Distribution.DeserializeDistribution(dp.Distribution).AssertSome()
)
)
.ToArr();
RequireNotNull(dto.Outputs);
var outputs = dto.Outputs
.Select(@do => new ModelOutput(
@do.Name.AssertNotNull(),
ErrorModel.DeserializeErrorModel(@do.ErrorModel.AssertNotNull()).AssertSome()
)
)
.ToArr();
var observations = dto.ObservationsReferences.IsNullOrEmpty()
? default
: dto.ObservationsReferences
.Select(r => evidence.GetObservations(r))
.Somes()
.ToArr();
return(new EstimationDesign(
createdOn,
priors,
outputs,
observations,
dto.Iterations,
dto.BurnIn,
dto.Chains,
dto.TargetAcceptRate,
dto.UseApproximation
));
}
catch (Exception ex)
{
var message = $"Failed to load estimation design from {pathToDesign}";
Log.Error(ex, message);
throw new Exception(message);
}
}
public static SimEvidenceSource GetEvidenceSource(this ISimEvidence evidence, int id) =>
evidence.EvidenceSources
.Find(es => es.ID == id)
.AssertSome($"Unknown evidence source: {id}");
