public override Task <ModelOutputMapping> MapToModel(SnapshotOutputMapping snapshot, ParameterIdentificationContext context)
{
var outputSelection = outputSelectionFrom(snapshot.Path, context.Project);
if (outputSelection == null)
{
return(Task.FromResult <ModelOutputMapping>(null));
}
var observedData = context.Project.AllObservedData.FindByName(snapshot.ObservedData);
var weightedObservedData = new WeightedObservedData(observedData);
if (snapshot.Weights != null)
{
updateWeights(weightedObservedData.Weights, snapshot.Weights);
}
var outputMapping = new ModelOutputMapping
{
Scaling = snapshot.Scaling,
Weight = ModelValueFor(snapshot.Weight, Constants.DEFAULT_WEIGHT),
OutputSelection = outputSelection,
WeightedObservedData = weightedObservedData
};
return(Task.FromResult(outputMapping));
}
private void raiseObservedDataUnmappedFor(WeightedObservedData weightedObservedData)
{
if (weightedObservedData != null)
{
ObservedDataUnmapped(this, new ObservedDataEventArgs(weightedObservedData));
}
}
private DataColumn createWeightColumn(BaseGrid baseGrid, WeightedObservedData weightedObservedData)
{
return(new DataColumn(Captions.ParameterIdentification.Weight, _dimensionFactory.NoDimension, baseGrid)
{
Values = weightedObservedData.Weights
});
}
public DataTable MapFrom(WeightedObservedData weightedObservedData)
{
var columns = weightedObservedData.ObservedData.ToList();
var dataColumn = createWeightColumn(weightedObservedData.ObservedData.BaseGrid, weightedObservedData);
columns.Add(dataColumn);
return(_dataRepositoryTask.ToDataTable(columns, forceColumnTypeAsObject: true).First());
}
private IParameterIdentificationWeightedObservedDataPresenter edit(WeightedObservedData weightedObservedData)
{
var observedDataPresenter = _allObservedDataPresenters[weightedObservedData];
observedDataPresenter?.Edit(weightedObservedData);
return(observedDataPresenter);
}
protected override void Context()
{
base.Context();
#pragma warning disable 618
_weightedObservedData = new WeightedObservedData();
#pragma warning restore 618
_outputMapping.WeightedObservedData = _weightedObservedData;
}
protected override void Context()
{
sut = new ParameterIdentification();
_observedData = new WeightedObservedData(DomainHelperForSpecs.ObservedData());
_simulation = A.Fake <ISimulation>().WithName("Sim").WithId("Id");
_quantitySelection = new QuantitySelection("Organism|Liver|Cell|Asprin|Concentration", QuantityType.Drug);
_outputMapping = new OutputMapping {
WeightedObservedData = _observedData, OutputSelection = new SimulationQuantitySelection(_simulation, _quantitySelection)
};
}
protected override void Context()
{
base.Context();
_outputMapping1.WeightedObservedData = null;
_parameterIdentification.AddOutputMapping(_outputMapping1);
_parameterIdentification.AddOutputMapping(_outputMapping2);
sut.EditParameterIdentification(_parameterIdentification);
sut.ObservedDataMapped += (o, e) => { _eventObservedData = e.WeightedObservedData; };
sut.ObservedDataUnmapped += (o, e) => { _unmappedRaised = true; };
}
public void RemoveObservedData(WeightedObservedData weightedObservedData)
{
var presenter = _allObservedDataPresenters[weightedObservedData];
if (presenter == null)
{
return;
}
_allObservedDataPresenters.Remove(weightedObservedData);
removeObservedDataPresenter(presenter);
}
public void Edit(WeightedObservedData weightedObservedData)
{
if (_alreadyEditing)
{
return;
}
_dataPresenter.EditObservedData(weightedObservedData);
_chartPresenter.PlotObservedData(weightedObservedData);
_chartPresenter.LogLinSelectionEnabled = true;
_chartPresenter.HotTracked = hotTracked;
Caption = weightedObservedData.DisplayName;
_alreadyEditing = true;
}
protected override void Context()
{
_simpleChartPresenter = A.Fake <ISimpleChartPresenter>();
_weightedDataRepositoryDataPresenter = A.Fake <IWeightedDataRepositoryDataPresenter>();
_view = A.Fake <IParameterIdentificationWeightedObservedDataView>();
var dataRepository = new DataRepository {
Name = "weightedObservedData"
};
dataRepository.Add(new BaseGrid("name", DomainHelperForSpecs.TimeDimensionForSpecs()));
_weightedObservedData = new WeightedObservedData(dataRepository);
sut = new ParameterIdentificationWeightedObservedDataPresenter(_view, _weightedDataRepositoryDataPresenter, _simpleChartPresenter);
}
public void SelectObservedData(WeightedObservedData weightedObservedData)
{
if (IsLatched)
{
return;
}
var observedDataPresenter = edit(weightedObservedData);
if (observedDataPresenter == null)
{
return;
}
_view.SelectObservedDataView(observedDataPresenter.View);
}
private float[] weightsFrom(WeightedObservedData weightedObservedData)
{
var weights = weightedObservedData?.Weights;
if (weights == null)
{
return(null);
}
if (weights.All(x => ValueComparer.AreValuesEqual(x, Constants.DEFAULT_WEIGHT)))
{
return(null);
}
return(weights);
}
protected override void Context()
{
_eventPublisher = A.Fake <IEventPublisher>();
_view = A.Fake <IParameterIdentificationWeightedObservedDataCollectorView>();
_applicationController = A.Fake <IApplicationController>();
sut = new ParameterIdentificationWeightedObservedDataCollectorPresenter(_view, _applicationController, _eventPublisher);
_parameterIdentification = new ParameterIdentification();
_weightedObservedData = new WeightedObservedData(DomainHelperForSpecs.ObservedData());
_outputMapping = new OutputMapping {
WeightedObservedData = _weightedObservedData
};
_parameterIdentification.AddOutputMapping(_outputMapping);
_presenter = A.Fake <IParameterIdentificationWeightedObservedDataPresenter>();
A.CallTo(() => _applicationController.Start <IParameterIdentificationWeightedObservedDataPresenter>()).Returns(_presenter);
}
public void AddObservedData(WeightedObservedData weightedObservedData)
{
// You can get a null weighted observed data when a mapping has not been assigned observed data yet or if mapping is corrupted
if (weightedObservedData?.ObservedData == null)
{
return;
}
if (_allObservedDataPresenters.Contains(weightedObservedData))
{
return;
}
var presenter = _applicationController.Start <IParameterIdentificationWeightedObservedDataPresenter>();
_allObservedDataPresenters.Add(weightedObservedData, presenter);
edit(weightedObservedData);
_view.AddObservedDataView(presenter.View);
SelectObservedData(weightedObservedData);
}
public void ObservedDataSelectionChanged(OutputMappingDTO dto, DataRepository newObservedData, DataRepository oldObservedData)
{
var allOutputsUsingObservedData = _allOutputMappingDTOs.Where(x => Equals(x.ObservedData, newObservedData)).Except(new[] { dto }).ToList();
if (observedDataAlreadySelectedForSameOutput(dto.Output, newObservedData))
{
dto.ObservedData = oldObservedData;
View.CloseEditor();
throw new CannotSelectTheObservedDataMoreThanOnceException(newObservedData);
}
var weightedObservedData = new WeightedObservedData(newObservedData)
{
Id = nextUniqueIdFor(allOutputsUsingObservedData)
};
raiseObservedDataUnmappedFor(dto.WeightedObservedData);
dto.Mapping.WeightedObservedData = weightedObservedData;
View.CloseEditor();
raiseObservedDataMappedFor(dto.WeightedObservedData);
}
protected override void Context()
{
_dataRepositoryTask = A.Fake <IDataRepositoryTask>();
_dimensionFactory = A.Fake <IDimensionFactory>();
sut = new WeightedDataRepositoryToDataTableMapper(_dataRepositoryTask, _dimensionFactory);
var baseGrid = new BaseGrid("name", _dimensionFactory.NoDimension)
{
Values = new[] { 0.0f }
};
var dataColumn = new DataColumn {
Values = new[] { 0.0f }
};
_dataRepository = new DataRepository {
baseGrid, dataColumn
};
_weightedObservedData = new WeightedObservedData(_dataRepository);
A.CallTo(() => _dataRepositoryTask.ToDataTable(A <IEnumerable <DataColumn> > ._, A <bool> ._, A <bool> ._, A <bool> ._)).Returns(new[] { new DataTable() });
}
protected override void Context()
{
_view = A.Fake <IWeightedDataRepositoryDataView>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_weightedDataRepositoryToDataTableMapper = A.Fake <IWeightedDataRepositoryToDataTableMapper>();
var baseGrid = new BaseGrid("name", _dimensionFactory.NoDimension)
{
Values = new[] { 0.0f }
};
var dataColumn = new DataColumn {
Values = new[] { 0.0f }
};
_dataRepository = new DataRepository {
baseGrid, dataColumn
};
_weightedObservedData = new WeightedObservedData(_dataRepository);
A.CallTo(() => _weightedDataRepositoryToDataTableMapper.MapFrom(_weightedObservedData)).Returns(new DataTable());
sut = new WeightedDataRepositoryDataPresenter(_view, _weightedDataRepositoryToDataTableMapper);
}
private void observedDataUnmapped(WeightedObservedData weightedObservedData)
{
_weightedObservedDataCollectorPresenter.RemoveObservedData(weightedObservedData);
}
private void raiseObservedDataMappedFor(WeightedObservedData weightedObservedData)
{
ObservedDataMapped(this, new ObservedDataEventArgs(weightedObservedData));
}
public ObservedDataEventArgs(WeightedObservedData weightedObservedData)
{
WeightedObservedData = weightedObservedData;
}
private void observedDataMapped(WeightedObservedData weightedObservedData)
{
_weightedObservedDataCollectorPresenter.AddObservedData(weightedObservedData);
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationOutputMappingView>();
_observedDataRepository = A.Fake <IObservedDataRepository>();
_entitiesInSimulationRetriever = A.Fake <IEntitiesInSimulationRetriever>();
_outputMappingDTOMapper = A.Fake <IOutputMappingToOutputMappingDTOMapper>();
_simulationQuantitySelectionDTOMapper = A.Fake <IQuantityToSimulationQuantitySelectionDTOMapper>();
_parameterIdentificationTask = A.Fake <IParameterIdentificationTask>();
sut = new ParameterIdentificationOutputMappingPresenter(_view, _entitiesInSimulationRetriever, _observedDataRepository, _outputMappingDTOMapper,
_simulationQuantitySelectionDTOMapper, _parameterIdentificationTask);
_observedData1 = DomainHelperForSpecs.ObservedData("Obs1").WithName("Obs1");
_weightedObservedData1 = new WeightedObservedData(_observedData1);
_observedData2 = DomainHelperForSpecs.ObservedData("Obs2").WithName("Obs2");
_weightedObservedData2 = new WeightedObservedData(_observedData2);
_parameterIdentification = new ParameterIdentification();
_simulation1 = A.Fake <ISimulation>().WithId("Id1");
_simulation2 = A.Fake <ISimulation>().WithId("Id2");
_usedObservedData1 = new UsedObservedData {
Id = "Obs1"
};
_usedObservedData2 = new UsedObservedData {
Id = "Obs2"
};
A.CallTo(() => _observedDataRepository.All()).Returns(new[] { _observedData1, _observedData2 });
A.CallTo(() => _observedDataRepository.AllObservedDataUsedBy(_simulation1)).Returns(new[] { _observedData2 });
A.CallTo(() => _observedDataRepository.AllObservedDataUsedBy(_simulation2)).Returns(new[] { _observedData1, _observedData2 });
_parameterIdentification.AddSimulation(_simulation1);
_parameterIdentification.AddSimulation(_simulation2);
_quantity1 = A.Fake <IQuantity>();
_quantity2 = A.Fake <IQuantity>();
_output1 = A.Fake <SimulationQuantitySelectionDTO>();
A.CallTo(() => _output1.Simulation).Returns(_simulation1);
_output2 = A.Fake <SimulationQuantitySelectionDTO>();
A.CallTo(() => _output2.Simulation).Returns(_simulation2);
A.CallTo(() => _entitiesInSimulationRetriever.OutputsFrom(_simulation1)).Returns(new PathCache <IQuantity>(new EntityPathResolverForSpecs())
{
{ "AA", _quantity1 }
});
A.CallTo(() => _entitiesInSimulationRetriever.OutputsFrom(_simulation2)).Returns(new PathCache <IQuantity>(new EntityPathResolverForSpecs())
{
{ "BB", _quantity2 }
});
A.CallTo(() => _simulationQuantitySelectionDTOMapper.MapFrom(_simulation1, _quantity1)).Returns(_output1);
A.CallTo(() => _simulationQuantitySelectionDTOMapper.MapFrom(_simulation2, _quantity2)).Returns(_output2);
A.CallTo(() => _view.BindTo(A <IEnumerable <OutputMappingDTO> > ._))
.Invokes(x => _allOutputMappingDTOs = x.GetArgument <IEnumerable <OutputMappingDTO> >(0));
sut.EditParameterIdentification(_parameterIdentification);
_outputMapping1 = A.Fake <OutputMapping>();
_outputMapping2 = A.Fake <OutputMapping>();
_outputMappingDTO1 = new OutputMappingDTO(_outputMapping1)
{
Output = _output1
};
_outputMappingDTO2 = new OutputMappingDTO(_outputMapping2)
{
Output = _output2
};
A.CallTo(() => _outputMapping1.Simulation).Returns(_simulation1);
A.CallTo(() => _outputMapping2.Simulation).Returns(_simulation2);
A.CallTo(() => _outputMappingDTOMapper.MapFrom(_outputMapping1, A <IEnumerable <SimulationQuantitySelectionDTO> > ._)).Returns(_outputMappingDTO1);
A.CallTo(() => _outputMappingDTOMapper.MapFrom(_outputMapping2, A <IEnumerable <SimulationQuantitySelectionDTO> > ._)).Returns(_outputMappingDTO2);
}
private void observedDataSelected(WeightedObservedData weightedObservedData)
{
_weightedObservedDataCollectorPresenter.SelectObservedData(weightedObservedData);
}
protected override void Context()
{
base.Context();
_weightedObservedData = A.Fake <WeightedObservedData>();
}
public void EditObservedData(WeightedObservedData weightedObservedData)
{
_weightedObservedData = weightedObservedData;
EditObservedData(weightedObservedData.ObservedData);
}
