private void deleteSimulationComparison(ISimulationComparison simulationComparison)
{
_applicationController.Close(simulationComparison);
_executionContext.CurrentProject.RemoveSimulationComparison(simulationComparison);
_executionContext.Unregister(simulationComparison);
_executionContext.PublishEvent(new SimulationComparisonDeletedEvent(_executionContext.CurrentProject, simulationComparison));
}
private void addComparisonToProject(ISimulationComparison simulationComparison)
{
simulationComparison.Name = createUniqueComparisonName();
_executionContext.CurrentProject.AddSimulationComparison(simulationComparison);
simulationComparison.IsLoaded = true;
_executionContext.PublishEvent(new SimulationComparisonCreatedEvent(_executionContext.CurrentProject, simulationComparison));
}
private SimulationComparisonMetaData mapFrom(ISimulationComparison simulationComparison)
{
SimulationComparisonMetaData metaData;
if (simulationComparison.IsAnImplementationOf <IndividualSimulationComparison>())
{
metaData = new IndividualSimulationComparisonMetaData();
}
else if (simulationComparison.IsAnImplementationOf <PopulationSimulationComparison>())
{
metaData = new PopulationSimulationComparisonMetaData();
}
else
{
throw new ArgumentException($"Unable to serialize simulation comparison of type {simulationComparison.GetType()}");
}
mapObjectBase(metaData, simulationComparison);
if (!simulationComparison.IsLoaded)
{
return(metaData);
}
serializeContent(metaData, simulationComparison, compress: true);
return(metaData);
}
public ApplicationIcon IconFor(ISimulationComparison simulationComparison)
{
if (simulationComparison.IsAnImplementationOf <PopulationSimulationComparison>())
{
return(ApplicationIcons.PopulationSimulationComparison);
}
return(ApplicationIcons.IndividualSimulationComparison);
}
protected override void Context()
{
_individualSimulationComparison = new IndividualSimulationComparison();
_simulationComparisonTask = A.Fake <ISimulationComparisonTask>();
_simulationComparisonToDelete = new[] { _individualSimulationComparison };
sut = new DeleteSimulationComparisonsUICommand(_simulationComparisonTask)
{
Subject = _simulationComparisonToDelete
};
}
public void RemoveSimulationComparison(ISimulationComparison simulationComparison)
{
if (!_simulationComparisons.Contains(simulationComparison))
{
return;
}
_simulationComparisons.Remove(simulationComparison);
RemoveClassifiableForWrappedObject(simulationComparison);
_hasChanged = true;
}
public void LoadContentFor(ISimulationComparison simulationComparison)
{
var content = _simulationComparisonMetaDataContentQuery.ResultFor(simulationComparison.Id);
if (content == null)
{
return;
}
_compressedSerializationManager.Deserialize(simulationComparison, content.Data);
}
private static void updateComparisonUsedObservedData(ISimulationComparison simulationComparison)
{
var comparison = simulationComparison as IndividualSimulationComparison;
if (comparison == null)
{
return;
}
var repositories = comparison.Curves.Select(x => x.xData.Repository).Union(comparison.Curves.Select(x => x.yData.Repository)).Distinct();
repositories.Each(repository => comparison.AddObservedData(repository));
}
public SimulationComparisonCreatedEvent(IProject project, ISimulationComparison simulationComparison)
: base(project)
{
SimulationComparison = simulationComparison;
}
protected override Task Context()
{
_classificationMapper = A.Fake <ClassificationMapper>();
_snapshotMapper = A.Fake <ISnapshotMapper>();
_executionContext = A.Fake <IExecutionContext>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_simulationMapper = A.Fake <SimulationMapper>();
_simulationComparisonMapper = A.Fake <SimulationComparisonMapper>();
_parameterIdentificationMapper = A.Fake <ParameterIdentificationMapper>();
_classificationSnapshotTask = A.Fake <IClassificationSnapshotTask>();
_qualificationPlanMapper = A.Fake <QualificationPlanMapper>();
_creationMetaDataFactory = A.Fake <ICreationMetaDataFactory>();
_logger = A.Fake <ILogger>();
sut = new ProjectMapper(
_simulationMapper,
_simulationComparisonMapper,
_parameterIdentificationMapper,
_qualificationPlanMapper,
_executionContext,
_classificationSnapshotTask,
_lazyLoadTask,
_creationMetaDataFactory,
_logger);
A.CallTo(() => _executionContext.Resolve <ISnapshotMapper>()).Returns(_snapshotMapper);
_individual = new Individual().WithName("IND");
_compound = new Compound().WithName("COMP");
_event = new PKSimEvent().WithName("EVENT");
_formulation = new Formulation().WithName("FORM");
_protocol = new SimpleProtocol().WithName("PROTO");
_population = new RandomPopulation().WithName("POP");
_observedData = new DataRepository().WithName("OD");
_parameterIdentification = new OSPSuite.Core.Domain.ParameterIdentifications.ParameterIdentification().WithName("PI").WithId("PI_ID");
_classifiableObservedData = new ClassifiableObservedData {
Subject = _observedData
};
_classification = new Classification {
ClassificationType = ClassificationType.ObservedData
}.WithName("OD Classification");
_simulationComparison = new IndividualSimulationComparison().WithName("COMP").WithId("SimComp");
_simulation = new IndividualSimulation().WithName("IND_SIM").WithId("IndSim");
_qualificationPlan = new QualificationPlan().WithName("QP").WithId("QP_ID");
_project = new PKSimProject();
_project.AddBuildingBlock(_individual);
_project.AddBuildingBlock(_compound);
_project.AddBuildingBlock(_event);
_project.AddBuildingBlock(_formulation);
_project.AddBuildingBlock(_protocol);
_project.AddBuildingBlock(_population);
_project.AddObservedData(_observedData);
_project.AddBuildingBlock(_simulation);
_project.AddClassifiable(_classifiableObservedData);
_project.AddClassification(_classification);
_project.AddSimulationComparison(_simulationComparison);
_project.AddParameterIdentification(_parameterIdentification);
_project.AddQualificationPlan(_qualificationPlan);
_compoundSnapshot = new Snapshots.Compound();
_individualSnapshot = new Snapshots.Individual();
_eventSnapshot = new Event();
_formulationSnapshot = new Snapshots.Formulation();
_protocolSnapshot = new Snapshots.Protocol();
_populationSnapshot = new Snapshots.Population();
_observedDataSnapshot = new Snapshots.DataRepository();
_parameterIdentificationSnapshot = new ParameterIdentification();
_observedDataClassificationSnapshot = new Snapshots.Classification();
_simulationComparisonSnapshot = new SimulationComparison();
_simulationClassificationSnapshot = new Snapshots.Classification();
_comparisonClassificationSnapshot = new Snapshots.Classification();
_parameterIdentificationClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanClassificationSnapshot = new Snapshots.Classification();
_qualificationPlanSnapshot = new Snapshots.QualificationPlan();
_simulationSnapshot = new Simulation();
A.CallTo(() => _snapshotMapper.MapToSnapshot(_compound)).Returns(_compoundSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_individual)).Returns(_individualSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_event)).Returns(_eventSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_formulation)).Returns(_formulationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_protocol)).Returns(_protocolSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_population)).Returns(_populationSnapshot);
A.CallTo(() => _snapshotMapper.MapToSnapshot(_observedData)).Returns(_observedDataSnapshot);
A.CallTo(() => _simulationMapper.MapToSnapshot(_simulation, _project)).Returns(_simulationSnapshot);
A.CallTo(() => _simulationComparisonMapper.MapToSnapshot(_simulationComparison)).Returns(_simulationComparisonSnapshot);
A.CallTo(() => _parameterIdentificationMapper.MapToSnapshot(_parameterIdentification, _project)).Returns(_parameterIdentificationSnapshot);
A.CallTo(() => _qualificationPlanMapper.MapToSnapshot(_qualificationPlan)).Returns(_qualificationPlanSnapshot);
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableObservedData>(_project)).Returns(new[] { _observedDataClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableSimulation>(_project)).Returns(new[] { _simulationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableComparison>(_project)).Returns(new[] { _comparisonClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableParameterIdentification>(_project)).Returns(new[] { _parameterIdentificationClassificationSnapshot });
A.CallTo(() => _classificationSnapshotTask.MapClassificationsToSnapshots <ClassifiableQualificationPlan>(_project)).Returns(new[] { _qualificationPlanClassificationSnapshot });
return(_completed);
}
public static XElement CreateSimulationReferenceListElement <TSimulation>(this IXmlSerializerRepository <SerializationContext> serializerRepository, ISimulationComparison <TSimulation> simulationComparison) where TSimulation : Simulation
{
return(serializerRepository.CreateObjectReferenceListElement(simulationComparison, x => x.AllSimulations, CoreConstants.Serialization.SimulationList, CoreConstants.Serialization.Simulation));
}
protected override async Task Because()
{
_simulationComparison = await sut.MapToModel(_snapshot, _snapshotContext);
}
private ITreeNode addSimulationComparisonToTree(ISimulationComparison simulationComparison)
{
return(AddSubjectToClassifyToTree <ISimulationComparison, ClassifiableComparison>(simulationComparison, addClassifiableComparisonToRootFolder));
}
public SimulationComparisonDeletedEvent(IProject project, ISimulationComparison chart)
: base(project)
{
Chart = chart;
}
public static void AddReferencedSimulations <TSimulation>(this XElement comparisonElement, ISimulationComparison <TSimulation> simulationComparison, IWithIdRepository withIdRepository, ILazyLoadTask lazyLoadTask) where TSimulation : Simulation
{
comparisonElement.AddReferencedObject <ISimulationComparison <TSimulation>, TSimulation>(
simulationComparison, x => x.AddSimulation, withIdRepository, lazyLoadTask, CoreConstants.Serialization.Simulation);
}
private void addComparisonToProject(ModelProject project, ISimulationComparison simulationComparison)
{
addClassifiableToProject <ClassifiableComparison, ISimulationComparison>(project, simulationComparison, project.AddSimulationComparison);
}
public void AddSimulationComparison(ISimulationComparison simulationComparison)
{
_simulationComparisons.Add(simulationComparison);
_hasChanged = true;
}
