From 7ec67e1e236b799af55a4db8992aba6cb4d8985e Mon Sep 17 00:00:00 2001 From: Michael Sevestre Date: Wed, 12 Apr 2023 13:17:44 -0400 Subject: [PATCH 1/2] Fixes #1970 add simulation builder --- SolutionInfo.cs | 1 + .../Domain/Builder/ModelConfiguration.cs | 16 ++- .../Domain/Builder/SimulationBuilder.cs | 109 ++++++++++++++++ .../Domain/Builder/SimulationConfiguration.cs | 116 +----------------- src/OSPSuite.Core/Domain/CreationResult.cs | 5 +- .../ContainerBuilderToContainerMapper.cs | 30 ++--- ...ssignmentBuilderToEventAssignmentMapper.cs | 22 ++-- .../Mappers/EventBuilderToEventMapper.cs | 14 +-- .../EventGroupBuilderToEventGroupMapper.cs | 28 ++--- .../Mappers/FormulaBuilderToFormulaMapper.cs | 4 +- .../Domain/Mappers/IBuilderMapper.cs | 2 +- .../Domain/Mappers/ILocalMapper.cs | 4 +- .../MoleculeBuilderToMoleculeAmountMapper.cs | 22 ++-- ...NeighborhoodBuilderToNeighborhoodMapper.cs | 10 +- ...NeighborhoodCollectionToContainerMapper.cs | 18 +-- .../ObserverBuilderToObserverMapper.cs | 8 +- ...erCollectionToParameterCollectionMapper.cs | 32 ++--- .../ParameterBuilderToParameterMapper.cs | 6 +- .../Mappers/ProcessRateParameterCreator.cs | 12 +- .../ReactionBuilderToReactionMapper.cs | 22 ++-- ...onPartnerBuilderToReactionPartnerMapper.cs | 6 +- .../TransportBuilderToTransportMapper.cs | 22 ++-- src/OSPSuite.Core/Domain/Model.cs | 11 +- .../Domain/ModelCoreSimulation.cs | 6 +- .../Domain/ModelCoreSimulationExtensions.cs | 4 +- src/OSPSuite.Core/Domain/Module.cs | 20 +-- .../Domain/ModuleConfiguration.cs | 47 ++++++- .../Domain/Services/CalculationMethodTask.cs | 16 +-- .../Domain/Services/EventBuilderTask.cs | 18 +-- .../Domain/Services/IModelValidatorFactory.cs | 2 +- .../Domain/Services/ModelConstructor.cs | 74 +++++------ .../Domain/Services/ModelValidator.cs | 14 +-- .../MoleculePropertiesContainerTask.cs | 56 ++++----- .../Domain/Services/ObserverBuilderTask.cs | 16 +-- .../Domain/Services/QuantityValuesUpdater.cs | 6 +- .../Domain/Services/ReactionCreator.cs | 13 +- .../Domain/Services/TransportCreator.cs | 41 +++---- .../Services/CircularReferenceChecker.cs | 10 +- .../SimulationConfigurationDisposer.cs | 41 ------- src/OSPSuite.R/Domain/Simulation.cs | 2 +- .../ModelConstructorIntegrationTests.cs | 37 +++--- .../ModuleIntegrationTests.cs | 10 +- .../BuildingBlockXmlSerializerSpecs.cs | 20 +-- .../Serializers/ModelXmlSerializerSpecs.cs | 2 +- .../ModellingXmlSerializerBaseSpecs.cs | 4 +- .../SimulationXmlSerializerSpecs.cs | 5 +- .../SimulationPersistorSpecs.cs | 10 +- .../SpatialStructureSpecs.cs | 8 +- .../ModelCoreSimulationExtensionsSpecs.cs | 4 +- .../Domain/ModelValidatorSpecs.cs | 4 +- .../Domain/ModuleConfigurationSpecs.cs | 63 ++++++++++ .../OSPSuite.Core.Tests/Domain/ModuleSpecs.cs | 6 +- .../MoleculePropertiesContainerTaskSpecs.cs | 18 +-- .../ProcessRateParameterCreatorSpecs.cs | 24 ++-- .../Domain/ReactionCreatorSpecs.cs | 9 +- .../ContainerBuilderToContainerMapperSpecs.cs | 12 +- .../FormulaBuilderToFormulaMapperSpecs.cs | 15 +-- ...eculeBuilderToMoleculeAmountMapperSpecs.cs | 28 +++-- ...borhoodBuilderToNeighborhoodMapperSpecs.cs | 16 +-- .../ObserverBuilderToObserverMapperSpecs.cs | 30 ++--- ...lectionToParameterCollectionMapperSpecs.cs | 28 +++-- .../ReactionBuilderToReactionMapperSpecs.cs | 48 ++++---- ...tnerBuilderToReactionPartnerMapperSpecs.cs | 18 +-- .../TransportBuilderToTransportMapperSpecs.cs | 40 +++--- .../Services/CircularReferenceCheckerSpecs.cs | 27 ++-- .../Services/ObserverBuilderTaskSpecs.cs | 77 ++++++++---- .../ConcentrationBaseModelHelperForSpecs.cs | 7 +- .../ModelHelperForSpecs.cs | 2 +- .../ModuleHelperForSpecs.cs | 4 +- .../SimulationConfigurationForSpecs.cs | 15 --- 70 files changed, 808 insertions(+), 689 deletions(-) create mode 100644 src/OSPSuite.Core/Domain/Builder/SimulationBuilder.cs delete mode 100644 src/OSPSuite.Core/Services/SimulationConfigurationDisposer.cs create mode 100644 tests/OSPSuite.Core.Tests/Domain/ModuleConfigurationSpecs.cs delete mode 100644 tests/OSPSuite.HelpersForTests/SimulationConfigurationForSpecs.cs diff --git a/SolutionInfo.cs b/SolutionInfo.cs index 4a1e496fd..e3b8597c0 100644 --- a/SolutionInfo.cs +++ b/SolutionInfo.cs @@ -6,6 +6,7 @@ [assembly: AssemblyCopyright("Copyright © 2017 - present - Open Systems Pharmacology Community")] [assembly: ComVisible(false)] [assembly: InternalsVisibleTo("OSPSuite.Core.Tests")] +[assembly: InternalsVisibleTo("OSPSuite.HelperForTests")] [assembly: InternalsVisibleTo("OSPSuite.UI.Tests")] [assembly: InternalsVisibleTo("OSPSuite.Presentation.Tests")] [assembly: InternalsVisibleTo("OSPSuite.R.Tests")] diff --git a/src/OSPSuite.Core/Domain/Builder/ModelConfiguration.cs b/src/OSPSuite.Core/Domain/Builder/ModelConfiguration.cs index 6b500c272..ea51ade8a 100644 --- a/src/OSPSuite.Core/Domain/Builder/ModelConfiguration.cs +++ b/src/OSPSuite.Core/Domain/Builder/ModelConfiguration.cs @@ -1,22 +1,32 @@ namespace OSPSuite.Core.Domain.Builder { - public class ModelConfiguration + internal class ModelConfiguration { + public SimulationBuilder SimulationBuilder { get; } public IModel Model { get; } public SimulationConfiguration SimulationConfiguration { get; } - public ModelConfiguration(IModel model, SimulationConfiguration simulationConfiguration) + public ModelConfiguration(IModel model, SimulationConfiguration simulationConfiguration, SimulationBuilder simulationBuilder) { Model = model; SimulationConfiguration = simulationConfiguration; + SimulationBuilder = simulationBuilder; } public bool ShouldValidate => SimulationConfiguration.ShouldValidate; - public void Deconstruct(out IModel model, out SimulationConfiguration simulationConfiguration) + public void Deconstruct(out IModel model, out SimulationConfiguration simulationConfiguration, out SimulationBuilder simulationBuilder) { model = Model; simulationConfiguration = SimulationConfiguration; + simulationBuilder = SimulationBuilder; + } + + + public void Deconstruct(out IModel model, out SimulationBuilder simulationBuilder) + { + model = Model; + simulationBuilder = SimulationBuilder; } } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Builder/SimulationBuilder.cs b/src/OSPSuite.Core/Domain/Builder/SimulationBuilder.cs new file mode 100644 index 000000000..ab3fef0ec --- /dev/null +++ b/src/OSPSuite.Core/Domain/Builder/SimulationBuilder.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using OSPSuite.Utility.Collections; + +namespace OSPSuite.Core.Domain.Builder +{ + public class SimulationBuilder + { + private readonly SimulationConfiguration _simulationConfiguration; + + private readonly ObjectBaseCache _passiveTransports = new ObjectBaseCache(); + private readonly ObjectBaseCache _reactions = new ObjectBaseCache(); + private readonly ObjectBaseCache _eventGroups = new ObjectBaseCache(); + private readonly ObjectBaseCache _observers = new ObjectBaseCache(); + private readonly ObjectBaseCache _molecules = new ObjectBaseCache(); + private readonly StartValueCache _parameterStartValues = new StartValueCache(); + private readonly StartValueCache _moleculeStartValues = new StartValueCache(); + + private readonly Cache _builderCache = new Cache(onMissingKey: x => null); + + public SimulationBuilder(SimulationConfiguration simulationConfiguration) + { + _simulationConfiguration = simulationConfiguration; + performMerge(); + } + + internal IObjectBase BuilderFor(IObjectBase modelObject) => _builderCache[modelObject]; + + internal void AddBuilderReference(IObjectBase modelObject, IObjectBase builder) + { + _builderCache[modelObject] = builder; + } + + private IReadOnlyList all(Func propAccess) where T : IBuildingBlock => + _simulationConfiguration.ModuleConfigurations.Select(x => propAccess(x.Module)).Where(x => x != null).ToList(); + + private IEnumerable allBuilder(Func> propAccess) where T : IBuilder => + all(propAccess).SelectMany(x => x); + + private IEnumerable allStartValueBuilder(Func> propAccess) where T : IStartValue => + _simulationConfiguration.ModuleConfigurations.Select(propAccess).Where(x => x != null).SelectMany(x => x); + + internal IEnumerable AllPresentMolecules() + { + var moleculeNames = _moleculeStartValues + .Where(moleculeStartValue => moleculeStartValue.IsPresent) + .Select(moleculeStartValue => moleculeStartValue.MoleculeName) + .Distinct(); + + + return moleculeNames.Select(x => _molecules[x]).Where(m => m != null); + } + + internal IEnumerable AllPresentMoleculeValues() => + AllPresentMoleculeValuesFor(_molecules.Select(x => x.Name)); + + internal IEnumerable AllPresentMoleculeValuesFor(IEnumerable moleculeNames) + { + return _moleculeStartValues + .Where(msv => moleculeNames.Contains(msv.MoleculeName)) + .Where(msv => msv.IsPresent); + } + + internal IEnumerable AllFloatingMolecules() => Molecules.Where(x => x.IsFloating); + + internal IReadOnlyList AllPresentMoleculeNames() => AllPresentMoleculeNames(x => true); + + //Uses toArray so that the marshaling to R works out of the box (array vs list) + internal IReadOnlyList AllPresentMoleculeNames(Func query) => + AllPresentMolecules().Where(query).Select(x => x.Name).ToArray(); + + internal IReadOnlyList AllPresentFloatingMoleculeNames() => + AllPresentMoleculeNames(m => m.IsFloating); + + internal IReadOnlyList AllPresentStationaryMoleculeNames() => + AllPresentMoleculeNames(m => !m.IsFloating); + + internal IReadOnlyList AllPresentXenobioticFloatingMoleculeNames() => + AllPresentMoleculeNames(m => m.IsFloating && m.IsXenobiotic); + + internal IReadOnlyList AllPresentEndogenousStationaryMoleculeNames() => + AllPresentMoleculeNames(m => !m.IsFloating && !m.IsXenobiotic); + + internal IReadOnlyList AllPresentEndogenousMoleculeNames() => AllPresentMoleculeNames(m => !m.IsXenobiotic); + + private void performMerge() + { + _passiveTransports.AddRange(allBuilder(x => x.PassiveTransports)); + _reactions.AddRange(allBuilder(x => x.Reactions)); + _eventGroups.AddRange(allBuilder(x => x.EventGroups)); + _observers.AddRange(allBuilder(x => x.Observers)); + _molecules.AddRange(allBuilder(x => x.Molecules)); + _parameterStartValues.AddRange(allStartValueBuilder(x => x.SelectedParameterStartValues)); + _moleculeStartValues.AddRange(allStartValueBuilder(x => x.SelectedMoleculeStartValues)); + } + + internal IReadOnlyList SpatialStructures => all(x => x.SpatialStructure); + internal IReadOnlyCollection PassiveTransports => _passiveTransports; + internal IReadOnlyCollection Reactions => _reactions; + internal IReadOnlyCollection EventGroups => _eventGroups; + internal IReadOnlyCollection Observers => _observers; + internal IReadOnlyCollection Molecules => _molecules; + internal IReadOnlyCollection ParameterStartValues => _parameterStartValues; + internal IReadOnlyCollection MoleculeStartValues => _moleculeStartValues; + + internal IMoleculeBuilder MoleculeByName(string name) => _molecules[name]; + } +} \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Builder/SimulationConfiguration.cs b/src/OSPSuite.Core/Domain/Builder/SimulationConfiguration.cs index abb64ddb0..405ad5e99 100644 --- a/src/OSPSuite.Core/Domain/Builder/SimulationConfiguration.cs +++ b/src/OSPSuite.Core/Domain/Builder/SimulationConfiguration.cs @@ -1,8 +1,6 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using System.Linq; using OSPSuite.Core.Serialization.SimModel.Services; -using OSPSuite.Utility.Collections; using OSPSuite.Utility.Extensions; using OSPSuite.Utility.Visitor; @@ -13,17 +11,6 @@ public class SimulationConfiguration : IVisitable private readonly List _expressionProfiles = new List(); private readonly List _moduleConfigurations = new List(); private readonly List _allCalculationMethods = new List(); - - //Temporary objects used for model construction only - private readonly Cache _builderCache = new Cache(onMissingKey: x => null); - private readonly ObjectBaseCache _passiveTransports = new ObjectBaseCache(); - private readonly ObjectBaseCache _reactions = new ObjectBaseCache(); - private readonly ObjectBaseCache _eventGroups = new ObjectBaseCache(); - private readonly ObjectBaseCache _observers = new ObjectBaseCache(); - private readonly ObjectBaseCache _molecules = new ObjectBaseCache(); - private readonly StartValueCache _parameterStartValues = new StartValueCache(); - private readonly StartValueCache _moleculeStartValues = new StartValueCache(); - public SimModelExportMode SimModelExportMode { get; set; } = SimModelExportMode.Full; public bool ShouldValidate { get; set; } = true; @@ -43,113 +30,16 @@ public class SimulationConfiguration : IVisitable public virtual void AddCalculationMethod(ICoreCalculationMethod calculationMethodToAdd) => _allCalculationMethods.Add(calculationMethodToAdd); - public virtual IReadOnlyList SpatialStructures => all(x => x.SpatialStructure); - public virtual IReadOnlyCollection PassiveTransports => _passiveTransports; - public virtual IReadOnlyCollection Reactions => _reactions; - public virtual IReadOnlyCollection EventGroups => _eventGroups; - public virtual IReadOnlyCollection Observers => _observers; - public virtual IReadOnlyCollection Molecules => _molecules; - public virtual IReadOnlyCollection ParameterStartValues => _parameterStartValues; - public virtual IReadOnlyCollection MoleculeStartValues => _moleculeStartValues; - - public IMoleculeBuilder MoleculeByName(string name) => _molecules[name]; - - private IReadOnlyList all(Func propAccess) where T : IBuildingBlock => - _moduleConfigurations.Select(x => propAccess(x.Module)).Where(x => x != null).ToList(); - - private IEnumerable allBuilder(Func> propAccess) where T : IBuilder => - all(propAccess).SelectMany(x => x); - - private IEnumerable allStartValueBuilder(Func> propAccess) where T : IStartValue => - _moduleConfigurations.Select(propAccess).Where(x => x != null).SelectMany(x => x); - - public virtual IEnumerable AllPresentMolecules() - { - var moleculeNames = _moleculeStartValues - .Where(moleculeStartValue => moleculeStartValue.IsPresent) - .Select(moleculeStartValue => moleculeStartValue.MoleculeName) - .Distinct(); - - - return moleculeNames.Select(x => _molecules[x]).Where(m => m != null); - } - - public virtual IEnumerable AllPresentMoleculeValues() => - AllPresentMoleculeValuesFor(_molecules.Select(x => x.Name)); - - public virtual IEnumerable AllPresentMoleculeValuesFor(IEnumerable moleculeNames) + public IReadOnlyList All() where T : class, IBuildingBlock { - return _moleculeStartValues - .Where(msv => moleculeNames.Contains(msv.MoleculeName)) - .Where(msv => msv.IsPresent); + return ModuleConfigurations.Select(x=>x.BuildingBlock()).Where(x=>x!=null).ToList(); } - public virtual IEnumerable AllFloatingMolecules() => Molecules.Where(x => x.IsFloating); - - public virtual IReadOnlyList AllPresentMoleculeNames() => AllPresentMoleculeNames(x => true); - - //Uses toArray so that the marshaling to R works out of the box (array vs list) - public virtual IReadOnlyList AllPresentMoleculeNames(Func query) => - AllPresentMolecules().Where(query).Select(x => x.Name).ToArray(); - - public virtual IReadOnlyList AllPresentFloatingMoleculeNames() => - AllPresentMoleculeNames(m => m.IsFloating); - - public virtual IReadOnlyList AllPresentStationaryMoleculeNames() => - AllPresentMoleculeNames(m => !m.IsFloating); - - public virtual IReadOnlyList AllPresentXenobioticFloatingMoleculeNames() => - AllPresentMoleculeNames(m => m.IsFloating && m.IsXenobiotic); - - public virtual IReadOnlyList AllPresentEndogenousStationaryMoleculeNames() => - AllPresentMoleculeNames(m => !m.IsFloating && !m.IsXenobiotic); - - public virtual IReadOnlyList AllPresentEndogenousMoleculeNames() => AllPresentMoleculeNames(m => !m.IsXenobiotic); - - public virtual IObjectBase BuilderFor(IObjectBase modelObject) => _builderCache[modelObject]; - - public virtual void AddBuilderReference(IObjectBase modelObject, IObjectBase builder) - { - _builderCache[modelObject] = builder; - } - - //TODO clone? Update from? - public virtual void AcceptVisitor(IVisitor visitor) { ModuleConfigurations.Each(x => x.AcceptVisitor(visitor)); Individual?.AcceptVisitor(visitor); _expressionProfiles.Each(x => x.AcceptVisitor(visitor)); } - - //Internal because this should not be called outside of core. - internal void Freeze() - { - ClearCache(); - _passiveTransports.AddRange(allBuilder(x => x.PassiveTransports)); - _reactions.AddRange(allBuilder(x => x.Reactions)); - _eventGroups.AddRange(allBuilder(x => x.EventGroups)); - _observers.AddRange(allBuilder(x => x.Observers)); - _molecules.AddRange(allBuilder(x => x.Molecules)); - _parameterStartValues.AddRange(allStartValueBuilder(x => x.SelectedParameterStartValues)); - _moleculeStartValues.AddRange(allStartValueBuilder(x => x.SelectedMoleculeStartValues)); - } - - internal void ClearCache() - { - ClearBuilderCache(); - _passiveTransports.Clear(); - _reactions.Clear(); - _eventGroups.Clear(); - _observers.Clear(); - _molecules.Clear(); - _parameterStartValues.Clear(); - _moleculeStartValues.Clear(); - } - - public virtual void ClearBuilderCache() - { - _builderCache.Clear(); - } } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/CreationResult.cs b/src/OSPSuite.Core/Domain/CreationResult.cs index e65ac15c5..5974ba1bf 100644 --- a/src/OSPSuite.Core/Domain/CreationResult.cs +++ b/src/OSPSuite.Core/Domain/CreationResult.cs @@ -1,15 +1,18 @@ using System.Linq; +using OSPSuite.Core.Domain.Builder; namespace OSPSuite.Core.Domain { public class CreationResult { public virtual IModel Model { get; } + public SimulationBuilder SimulationBuilder { get; } public virtual ValidationResult ValidationResult { get; private set; } - public CreationResult(IModel model) + public CreationResult(IModel model, SimulationBuilder simulationBuilder) { Model = model; + SimulationBuilder = simulationBuilder; ValidationResult = new ValidationResult(); } diff --git a/src/OSPSuite.Core/Domain/Mappers/ContainerBuilderToContainerMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ContainerBuilderToContainerMapper.cs index 097673667..a85b1ee20 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ContainerBuilderToContainerMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ContainerBuilderToContainerMapper.cs @@ -1,19 +1,21 @@ -using OSPSuite.Utility.Extensions; -using OSPSuite.Core.Domain.Builder; +using OSPSuite.Core.Domain.Builder; using OSPSuite.Core.Domain.Services; +using OSPSuite.Utility.Extensions; namespace OSPSuite.Core.Domain.Mappers { /// - /// Maps container used in a building block to model container - /// At the moment, there is no special ContainerBuilder class, so the mapper - /// will just create the clone of the input container + /// Maps container used in a building block to model container + /// + /// At the moment, there is no special ContainerBuilder class, so the mapper + /// + /// will just create the clone of the input container /// public interface IContainerBuilderToContainerMapper : IBuilderMapper { } - public class ContainerBuilderToContainerMapper : IContainerBuilderToContainerMapper + internal class ContainerBuilderToContainerMapper : IContainerBuilderToContainerMapper { private readonly ICloneManagerForModel _cloneManagerForModel; @@ -22,26 +24,26 @@ public ContainerBuilderToContainerMapper(ICloneManagerForModel cloneManagerForMo _cloneManagerForModel = cloneManagerForModel; } - public IContainer MapFrom(IContainer containerBuilder, SimulationConfiguration simulationConfiguration) + public IContainer MapFrom(IContainer containerBuilder, SimulationBuilder simulationBuilder) { - var container= _cloneManagerForModel.Clone(containerBuilder); - addBuilderReference(container, containerBuilder, simulationConfiguration); + var container = _cloneManagerForModel.Clone(containerBuilder); + addBuilderReference(container, containerBuilder, simulationBuilder); return container; } - private void addBuilderReference(IContainer container, IContainer containerBuilder, SimulationConfiguration simulationConfiguration) + private void addBuilderReference(IContainer container, IContainer containerBuilder, SimulationBuilder simulationBuilder) { if (container == null || containerBuilder == null) return; - simulationConfiguration.AddBuilderReference(container, containerBuilder); + simulationBuilder.AddBuilderReference(container, containerBuilder); foreach (var childBuilder in containerBuilder.Children) { var child = container.GetSingleChildByName(childBuilder.Name); - if(child.IsAnImplementationOf()) - addBuilderReference(child.DowncastTo(), childBuilder as IContainer, simulationConfiguration); + if (child.IsAnImplementationOf()) + addBuilderReference(child.DowncastTo(), childBuilder as IContainer, simulationBuilder); else - simulationConfiguration.AddBuilderReference(child, childBuilder); + simulationBuilder.AddBuilderReference(child, childBuilder); } } } diff --git a/src/OSPSuite.Core/Domain/Mappers/EventAssignmentBuilderToEventAssignmentMapper.cs b/src/OSPSuite.Core/Domain/Mappers/EventAssignmentBuilderToEventAssignmentMapper.cs index b7ff4e6db..7651360f0 100644 --- a/src/OSPSuite.Core/Domain/Mappers/EventAssignmentBuilderToEventAssignmentMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/EventAssignmentBuilderToEventAssignmentMapper.cs @@ -7,11 +7,11 @@ namespace OSPSuite.Core.Domain.Mappers /// /// Maps one event assignment from building block into model /// - public interface IEventAssignmentBuilderToEventAssignmentMapper : IBuilderMapper> + internal interface IEventAssignmentBuilderToEventAssignmentMapper : IBuilderMapper> { } - public class EventAssignmentBuilderToEventAssignmentMapper : IEventAssignmentBuilderToEventAssignmentMapper + internal class EventAssignmentBuilderToEventAssignmentMapper : IEventAssignmentBuilderToEventAssignmentMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly IFormulaBuilderToFormulaMapper _formulaMapper; @@ -22,37 +22,37 @@ public EventAssignmentBuilderToEventAssignmentMapper(IObjectBaseFactory objectBa _formulaMapper = formulaMapper; } - public IReadOnlyList MapFrom(IEventAssignmentBuilder assignmentBuilder, SimulationConfiguration simulationConfiguration) + public IReadOnlyList MapFrom(IEventAssignmentBuilder assignmentBuilder, SimulationBuilder simulationBuilder) { if (!isForAllFloating(assignmentBuilder)) - return new[] {createAssignment(assignmentBuilder, simulationConfiguration)}; + return new[] {createAssignment(assignmentBuilder, simulationBuilder) }; - return simulationConfiguration.AllFloatingMolecules() - .Select(x => createMoleculeAssignment(x, assignmentBuilder, simulationConfiguration)) + return simulationBuilder.AllFloatingMolecules() + .Select(x => createMoleculeAssignment(x, assignmentBuilder, simulationBuilder)) .ToList(); } - private IEventAssignment createMoleculeAssignment(IMoleculeBuilder moleculeBuilder, IEventAssignmentBuilder assignmentBuilder, SimulationConfiguration simulationConfiguration) + private IEventAssignment createMoleculeAssignment(IMoleculeBuilder moleculeBuilder, IEventAssignmentBuilder assignmentBuilder, SimulationBuilder simulationBuilder) { //We change the original name to ensure unicity in the container. //Assignment are named programatically and not by the user so there should not be any conflict. var name = $"{assignmentBuilder.Name}_{moleculeBuilder.Name}"; - var assignment = createAssignment(assignmentBuilder, simulationConfiguration, name); + var assignment = createAssignment(assignmentBuilder, simulationBuilder, name); assignment.ObjectPath.Replace(ObjectPathKeywords.ALL_FLOATING_MOLECULES, moleculeBuilder.Name); return assignment; } - private IEventAssignment createAssignment(IEventAssignmentBuilder assignmentBuilder, SimulationConfiguration simulationConfiguration, string name = null) + private IEventAssignment createAssignment(IEventAssignmentBuilder assignmentBuilder, SimulationBuilder simulationBuilder, string name = null) { var assignment = _objectBaseFactory.Create() .WithName(name ?? assignmentBuilder.Name) .WithDimension(assignmentBuilder.Dimension) - .WithFormula(_formulaMapper.MapFrom(assignmentBuilder.Formula, simulationConfiguration)); + .WithFormula(_formulaMapper.MapFrom(assignmentBuilder.Formula, simulationBuilder)); assignment.ObjectPath = assignmentBuilder.ObjectPath.Clone(); assignment.UseAsValue = assignmentBuilder.UseAsValue; - simulationConfiguration.AddBuilderReference(assignment, assignmentBuilder); + simulationBuilder.AddBuilderReference(assignment, assignmentBuilder); return assignment; } diff --git a/src/OSPSuite.Core/Domain/Mappers/EventBuilderToEventMapper.cs b/src/OSPSuite.Core/Domain/Mappers/EventBuilderToEventMapper.cs index 15d046166..c8a91729a 100644 --- a/src/OSPSuite.Core/Domain/Mappers/EventBuilderToEventMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/EventBuilderToEventMapper.cs @@ -7,11 +7,11 @@ namespace OSPSuite.Core.Domain.Mappers /// /// Maps event builder object to an model event /// - public interface IEventBuilderToEventMapper : IBuilderMapper + internal interface IEventBuilderToEventMapper : IBuilderMapper { } - public class EventBuilderToEventMapper : IEventBuilderToEventMapper + internal class EventBuilderToEventMapper : IEventBuilderToEventMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly IParameterBuilderToParameterMapper _parameterMapper; @@ -29,23 +29,23 @@ public EventBuilderToEventMapper(IObjectBaseFactory objectBaseFactory, _assignmentMapper = assignmentMapper; } - public IEvent MapFrom(IEventBuilder eventBuilder, SimulationConfiguration simulationConfiguration) + public IEvent MapFrom(IEventBuilder eventBuilder, SimulationBuilder simulationBuilder) { var modelEvent = _objectBaseFactory.Create() .WithName(eventBuilder.Name) .WithDimension(eventBuilder.Dimension) .WithDescription(eventBuilder.Description) - .WithFormula(_formulaMapper.MapFrom(eventBuilder.Formula, simulationConfiguration)); + .WithFormula(_formulaMapper.MapFrom(eventBuilder.Formula, simulationBuilder)); - simulationConfiguration.AddBuilderReference(modelEvent, eventBuilder); + simulationBuilder.AddBuilderReference(modelEvent, eventBuilder); eventBuilder.Assignments - .SelectMany(x => _assignmentMapper.MapFrom(x, simulationConfiguration)) + .SelectMany(x => _assignmentMapper.MapFrom(x, simulationBuilder)) .Each(modelEvent.AddAssignment); foreach (var param in eventBuilder.Parameters) { - modelEvent.Add(_parameterMapper.MapFrom(param, simulationConfiguration)); + modelEvent.Add(_parameterMapper.MapFrom(param, simulationBuilder)); } modelEvent.OneTime = eventBuilder.OneTime; diff --git a/src/OSPSuite.Core/Domain/Mappers/EventGroupBuilderToEventGroupMapper.cs b/src/OSPSuite.Core/Domain/Mappers/EventGroupBuilderToEventGroupMapper.cs index 6430cf284..e483c34a1 100644 --- a/src/OSPSuite.Core/Domain/Mappers/EventGroupBuilderToEventGroupMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/EventGroupBuilderToEventGroupMapper.cs @@ -5,11 +5,11 @@ namespace OSPSuite.Core.Domain.Mappers { - public interface IEventGroupBuilderToEventGroupMapper : IBuilderMapper + internal interface IEventGroupBuilderToEventGroupMapper : IBuilderMapper { } - public class EventGroupBuilderToEventGroupMapper : IEventGroupBuilderToEventGroupMapper + internal class EventGroupBuilderToEventGroupMapper : IEventGroupBuilderToEventGroupMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly ICloneManagerForModel _cloneManagerForModel; @@ -40,17 +40,17 @@ public EventGroupBuilderToEventGroupMapper( _parameterFactory = parameterFactory; } - public IEventGroup MapFrom(IEventGroupBuilder eventGroupBuilder, SimulationConfiguration simulationConfiguration) + public IEventGroup MapFrom(IEventGroupBuilder eventGroupBuilder, SimulationBuilder simulationBuilder) { var eventGroup = _objectBaseFactory.Create(); - simulationConfiguration.AddBuilderReference(eventGroup, eventGroupBuilder); + simulationBuilder.AddBuilderReference(eventGroup, eventGroupBuilder); eventGroup.UpdatePropertiesFrom(eventGroupBuilder, _cloneManagerForModel); eventGroup.EventGroupType = eventGroupBuilder.EventGroupType; - createEventGroupStructure(eventGroupBuilder, eventGroup, simulationConfiguration); + createEventGroupStructure(eventGroupBuilder, eventGroup, simulationBuilder); return eventGroup; } - private void createEventGroupStructure(IEventGroupBuilder eventGroupBuilder, IEventGroup eventGroup, SimulationConfiguration simulationConfiguration) + private void createEventGroupStructure(IEventGroupBuilder eventGroupBuilder, IEventGroup eventGroup, SimulationBuilder simulationBuilder) { foreach (var childBuilder in eventGroupBuilder.Children) { @@ -60,21 +60,21 @@ private void createEventGroupStructure(IEventGroupBuilder eventGroupBuilder, IEv if (childBuilder.IsAnImplementationOf()) { - var childEventGroup = MapFrom(childBuilder.DowncastTo(), simulationConfiguration); + var childEventGroup = MapFrom(childBuilder.DowncastTo(), simulationBuilder); eventGroup.Add(childEventGroup); if (childBuilder.IsAnImplementationOf()) - createApplication(childBuilder.DowncastTo(), childEventGroup, simulationConfiguration); + createApplication(childBuilder.DowncastTo(), childEventGroup, simulationBuilder); } else if (childBuilder.IsAnImplementationOf()) - eventGroup.Add(_eventMapper.MapFrom(childBuilder.DowncastTo(), simulationConfiguration)); + eventGroup.Add(_eventMapper.MapFrom(childBuilder.DowncastTo(), simulationBuilder)); else if (childBuilder.IsAnImplementationOf()) - eventGroup.Add(_parameterMapper.MapFrom(childBuilder.DowncastTo(), simulationConfiguration)); + eventGroup.Add(_parameterMapper.MapFrom(childBuilder.DowncastTo(), simulationBuilder)); else if (childBuilder.IsAnImplementationOf()) - eventGroup.Add(_containerMapper.MapFrom(childBuilder.DowncastTo(), simulationConfiguration)); + eventGroup.Add(_containerMapper.MapFrom(childBuilder.DowncastTo(), simulationBuilder)); else eventGroup.Add(_cloneManagerForModel.Clone(childBuilder)); @@ -86,7 +86,7 @@ private static bool doesNotBelongIntoModel(IEntity childBuilder) return childBuilder.IsAnImplementationOf() || childBuilder.IsAnImplementationOf(); } - private void createApplication(IApplicationBuilder applicationBuilder, IEventGroup eventGroup, SimulationConfiguration simulationConfiguration) + private void createApplication(IApplicationBuilder applicationBuilder, IEventGroup eventGroup, SimulationBuilder simulationBuilder) { //---- add molecule amounts foreach (var appMolecule in applicationBuilder.Molecules) @@ -94,8 +94,8 @@ private void createApplication(IApplicationBuilder applicationBuilder, IEventGro //get container for the molecule var moleculeContainer = appMolecule.RelativeContainerPath.Resolve(eventGroup); - var molecule = _moleculeMapper.MapFrom(simulationConfiguration.MoleculeByName(applicationBuilder.MoleculeName), moleculeContainer, simulationConfiguration); - molecule.Formula = _formulaMapper.MapFrom(appMolecule.Formula, simulationConfiguration); + var molecule = _moleculeMapper.MapFrom(simulationBuilder.MoleculeByName(applicationBuilder.MoleculeName), moleculeContainer, simulationBuilder); + molecule.Formula = _formulaMapper.MapFrom(appMolecule.Formula, simulationBuilder); moleculeContainer.Add(molecule); diff --git a/src/OSPSuite.Core/Domain/Mappers/FormulaBuilderToFormulaMapper.cs b/src/OSPSuite.Core/Domain/Mappers/FormulaBuilderToFormulaMapper.cs index e78bd09c1..97c67e1db 100644 --- a/src/OSPSuite.Core/Domain/Mappers/FormulaBuilderToFormulaMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/FormulaBuilderToFormulaMapper.cs @@ -17,7 +17,7 @@ public interface IFormulaBuilderToFormulaMapper : IBuilderMapper { - TOutput MapFrom(TInput input, SimulationConfiguration simulationConfiguration); + TOutput MapFrom(TInput input, SimulationBuilder simulationBuilder); } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Mappers/ILocalMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ILocalMapper.cs index c3a1351c5..1347bff48 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ILocalMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ILocalMapper.cs @@ -9,7 +9,7 @@ public interface ILocalMapper /// /// The input. /// The local information. - /// The build configuration - TOutput MapFromLocal(TInput input, TLocal container, SimulationConfiguration simulationConfiguration); + /// The build configuration + TOutput MapFromLocal(TInput input, TLocal container, SimulationBuilder simulationBuilder); } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Mappers/MoleculeBuilderToMoleculeAmountMapper.cs b/src/OSPSuite.Core/Domain/Mappers/MoleculeBuilderToMoleculeAmountMapper.cs index f7bfd167a..1eb411a28 100644 --- a/src/OSPSuite.Core/Domain/Mappers/MoleculeBuilderToMoleculeAmountMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/MoleculeBuilderToMoleculeAmountMapper.cs @@ -16,7 +16,7 @@ namespace OSPSuite.Core.Domain.Mappers /// /// (by the global molecule properties mapper) /// - public interface IMoleculeBuilderToMoleculeAmountMapper + internal interface IMoleculeBuilderToMoleculeAmountMapper { /// /// Maps the to a MoleculeAmount. is where the @@ -27,12 +27,12 @@ public interface IMoleculeBuilderToMoleculeAmountMapper /// Container where the molecule amount will be added. This is required in order to evaluate /// local parameters container criteria /// - /// Build configuration + /// Simulation builder /// - IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, SimulationConfiguration simulationConfiguration); + IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, SimulationBuilder simulationBuilder); } - public class MoleculeBuilderToMoleculeAmountMapper : IMoleculeBuilderToMoleculeAmountMapper + internal class MoleculeBuilderToMoleculeAmountMapper : IMoleculeBuilderToMoleculeAmountMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly IFormulaBuilderToFormulaMapper _formulaMapper; @@ -57,7 +57,7 @@ public MoleculeBuilderToMoleculeAmountMapper(IObjectBaseFactory objectBaseFactor _amountDimension = dimensionFactory.Dimension(Constants.Dimension.MOLAR_AMOUNT); } - public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, SimulationConfiguration simulationConfiguration) + public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, SimulationBuilder simulationBuilder) { //molecule amount always in amount var moleculeAmount = _objectBaseFactory.Create() @@ -69,9 +69,9 @@ public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targ .WithDimension(_amountDimension) .WithDisplayUnit(_amountDimension.UnitOrDefault(_amountDimension.DefaultUnit.Name)); - simulationConfiguration.AddBuilderReference(moleculeAmount, moleculeBuilder); + simulationBuilder.AddBuilderReference(moleculeAmount, moleculeBuilder); - createMoleculeAmountDefaultFormula(moleculeBuilder, simulationConfiguration, moleculeAmount); + createMoleculeAmountDefaultFormula(moleculeBuilder, simulationBuilder, moleculeAmount); //map parameters. Only parameters having BuildMode="Local" will //be added to the molecule amount. Global/Property-Parameters @@ -80,19 +80,19 @@ public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targ .Where(x => x.BuildMode == ParameterBuildMode.Local) .Where(x => x.ContainerCriteria?.IsSatisfiedBy(targetContainer) ?? true); - allLocalParameters.Each(x => moleculeAmount.Add(_parameterMapper.MapFrom(x, simulationConfiguration))); + allLocalParameters.Each(x => moleculeAmount.Add(_parameterMapper.MapFrom(x, simulationBuilder))); _keywordReplacerTask.ReplaceIn(moleculeAmount); return moleculeAmount; } - private void createMoleculeAmountDefaultFormula(IMoleculeBuilder moleculeBuilder, SimulationConfiguration simulationConfiguration, IMoleculeAmount moleculeAmount) + private void createMoleculeAmountDefaultFormula(IMoleculeBuilder moleculeBuilder, SimulationBuilder simulationBuilder, IMoleculeAmount moleculeAmount) { //set start value formula to the default. If user has specified //a new start value in MoleculesStartValueCollection-BB, default formula //will be overwritten during setting of molecule start values - var modelFormula = _formulaMapper.MapFrom(moleculeBuilder.DefaultStartFormula, simulationConfiguration); + var modelFormula = _formulaMapper.MapFrom(moleculeBuilder.DefaultStartFormula, simulationBuilder); //amount based, we can just the formula as is if (moleculeBuilder.IsAmountBased()) @@ -103,7 +103,7 @@ private void createMoleculeAmountDefaultFormula(IMoleculeBuilder moleculeBuilder //create a start value parameter that will be referenced in the molecule formula var startValueParameter = _parameterFactory.CreateStartValueParameter(moleculeAmount, modelFormula, moleculeBuilder.DisplayUnit); - simulationConfiguration.AddBuilderReference(startValueParameter, moleculeBuilder); + simulationBuilder.AddBuilderReference(startValueParameter, moleculeBuilder); moleculeAmount.Add(startValueParameter); moleculeAmount.Formula = _formulaFactory.CreateMoleculeAmountReferenceToStartValue(startValueParameter); } diff --git a/src/OSPSuite.Core/Domain/Mappers/NeighborhoodBuilderToNeighborhoodMapper.cs b/src/OSPSuite.Core/Domain/Mappers/NeighborhoodBuilderToNeighborhoodMapper.cs index 2d5ca7399..6dfe1e1ea 100644 --- a/src/OSPSuite.Core/Domain/Mappers/NeighborhoodBuilderToNeighborhoodMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/NeighborhoodBuilderToNeighborhoodMapper.cs @@ -9,7 +9,7 @@ namespace OSPSuite.Core.Domain.Mappers /// /// Maps neighborhood builder object into a neighborhood /// - public interface INeighborhoodBuilderToNeighborhoodMapper + internal interface INeighborhoodBuilderToNeighborhoodMapper { /// /// Maps neighborhood builder object into a neighborhood @@ -26,7 +26,7 @@ Neighborhood MapFrom(NeighborhoodBuilder neighborhoodBuilder, IEnumerable moleculeNamesWithCopyPropertiesRequired, ModelConfiguration modelConfiguration); } - public class NeighborhoodBuilderToNeighborhoodMapper : INeighborhoodBuilderToNeighborhoodMapper + internal class NeighborhoodBuilderToNeighborhoodMapper : INeighborhoodBuilderToNeighborhoodMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly IContainerBuilderToContainerMapper _containerMapper; @@ -34,10 +34,12 @@ public class NeighborhoodBuilderToNeighborhoodMapper : INeighborhoodBuilderToNei private readonly ICloneManagerForModel _cloneManagerForModel; private readonly IParameterBuilderToParameterMapper _parameterMapper; - public NeighborhoodBuilderToNeighborhoodMapper(IObjectBaseFactory objectBaseFactory, + public NeighborhoodBuilderToNeighborhoodMapper( + IObjectBaseFactory objectBaseFactory, IContainerBuilderToContainerMapper containerMapper, IKeywordReplacerTask keywordReplacerTask, - ICloneManagerForModel cloneManagerForModel, IParameterBuilderToParameterMapper parameterMapper) + ICloneManagerForModel cloneManagerForModel, + IParameterBuilderToParameterMapper parameterMapper) { _objectBaseFactory = objectBaseFactory; _containerMapper = containerMapper; diff --git a/src/OSPSuite.Core/Domain/Mappers/NeighborhoodCollectionToContainerMapper.cs b/src/OSPSuite.Core/Domain/Mappers/NeighborhoodCollectionToContainerMapper.cs index a916e8bed..ef264a16e 100644 --- a/src/OSPSuite.Core/Domain/Mappers/NeighborhoodCollectionToContainerMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/NeighborhoodCollectionToContainerMapper.cs @@ -14,11 +14,11 @@ namespace OSPSuite.Core.Domain.Mappers /// /// are added as children of this top container /// - public interface INeighborhoodCollectionToContainerMapper : IMapper + internal interface INeighborhoodCollectionToContainerMapper : IMapper { } - public class NeighborhoodCollectionToContainerMapper : INeighborhoodCollectionToContainerMapper + internal class NeighborhoodCollectionToContainerMapper : INeighborhoodCollectionToContainerMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly INeighborhoodBuilderToNeighborhoodMapper _neighborhoodMapper; @@ -33,18 +33,18 @@ public NeighborhoodCollectionToContainerMapper( public IContainer MapFrom(ModelConfiguration modelConfiguration) { - var (_, simulationConfiguration) = modelConfiguration; - var moleculeNames = simulationConfiguration.AllPresentFloatingMoleculeNames(); + var (_, simulationBuilder) = modelConfiguration; + var moleculeNames = simulationBuilder.AllPresentFloatingMoleculeNames(); var neighborhoodsParentContainer = _objectBaseFactory.Create() .WithMode(ContainerMode.Logical) .WithName(Constants.NEIGHBORHOODS); - var startValuesForFloatingMolecules = presentMoleculesCachedByContainerPath(moleculeNames, simulationConfiguration); + var startValuesForFloatingMolecules = presentMoleculesCachedByContainerPath(moleculeNames, simulationBuilder); - var moleculeNamesCopyProperties = simulationConfiguration.AllPresentXenobioticFloatingMoleculeNames(); + var moleculeNamesCopyProperties = simulationBuilder.AllPresentXenobioticFloatingMoleculeNames(); - simulationConfiguration.SpatialStructures.SelectMany(x => x.Neighborhoods).Each(nb => + simulationBuilder.SpatialStructures.SelectMany(x => x.Neighborhoods).Each(nb => neighborhoodsParentContainer.Add(_neighborhoodMapper.MapFrom(nb, moleculeNamesFor(nb, startValuesForFloatingMolecules), moleculeNamesCopyProperties, modelConfiguration))); @@ -52,9 +52,9 @@ public IContainer MapFrom(ModelConfiguration modelConfiguration) return neighborhoodsParentContainer; } - private ICache> presentMoleculesCachedByContainerPath(IEnumerable namesOfFloatingMolecules, SimulationConfiguration simulationConfiguration) + private ICache> presentMoleculesCachedByContainerPath(IEnumerable namesOfFloatingMolecules, SimulationBuilder simulationBuilder) { - var startValues = simulationConfiguration.AllPresentMoleculeValuesFor(namesOfFloatingMolecules).ToList(); + var startValues = simulationBuilder.AllPresentMoleculeValuesFor(namesOfFloatingMolecules).ToList(); var moleculeStartValuesPerContainer = new Cache>(); diff --git a/src/OSPSuite.Core/Domain/Mappers/ObserverBuilderToObserverMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ObserverBuilderToObserverMapper.cs index eb5cf2425..cb9075fd4 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ObserverBuilderToObserverMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ObserverBuilderToObserverMapper.cs @@ -9,7 +9,7 @@ public interface IObserverBuilderToObserverMapper : IBuilderMapper() .WithName(observerBuilder.Name) .WithIcon(observerBuilder.Icon) .WithDescription(observerBuilder.Description) .WithDimension(observerBuilder.Dimension) - .WithFormula(_formulaMapper.MapFrom(observerBuilder.Formula, simulationConfiguration)); + .WithFormula(_formulaMapper.MapFrom(observerBuilder.Formula, simulationBuilder)); - simulationConfiguration.AddBuilderReference(observer, observerBuilder); + simulationBuilder.AddBuilderReference(observer, observerBuilder); return observer; } } diff --git a/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderCollectionToParameterCollectionMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderCollectionToParameterCollectionMapper.cs index c3364614b..4d2fa6964 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderCollectionToParameterCollectionMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderCollectionToParameterCollectionMapper.cs @@ -12,30 +12,30 @@ public interface IParameterBuilderCollectionToParameterCollectionMapper /// /// Only parameters having one of will be mapped or all if was not specified /// - IEnumerable MapFrom(IEnumerable parameterBuilders, SimulationConfiguration simulationConfiguration, params ParameterBuildMode[] parameterBuildModesToMap); + IEnumerable MapFrom(IEnumerable parameterBuilders, SimulationBuilder simulationBuilder, params ParameterBuildMode[] parameterBuildModesToMap); /// /// Only direct children parameters of having one of will be mapped or all if was not specified /// - IEnumerable MapFrom(IContainer container, SimulationConfiguration simulationConfiguration, params ParameterBuildMode[] parameterBuildModesToMap); + IEnumerable MapFrom(IContainer container, SimulationBuilder simulationBuilder, params ParameterBuildMode[] parameterBuildModesToMap); /// /// Only direct children parameters of of type or will be mapped /// - IEnumerable MapGlobalOrPropertyFrom(IContainer container, SimulationConfiguration simulationConfiguration); + IEnumerable MapGlobalOrPropertyFrom(IContainer container, SimulationBuilder simulationBuilder); /// /// Only direct children parameters of of type will be mapped /// - IEnumerable MapLocalFrom(IContainer container, SimulationConfiguration simulationConfiguration); + IEnumerable MapLocalFrom(IContainer container, SimulationBuilder simulationBuilder); /// /// All direct children parameters of will be mapped /// - IEnumerable MapAllFrom(IContainer container, SimulationConfiguration simulationConfiguration); + IEnumerable MapAllFrom(IContainer container, SimulationBuilder simulationBuilder); } - public class ParameterBuilderCollectionToParameterCollectionMapper : IParameterBuilderCollectionToParameterCollectionMapper + internal class ParameterBuilderCollectionToParameterCollectionMapper : IParameterBuilderCollectionToParameterCollectionMapper { private readonly IParameterBuilderToParameterMapper _parameterMapper; @@ -44,30 +44,30 @@ public ParameterBuilderCollectionToParameterCollectionMapper(IParameterBuilderTo _parameterMapper = parameterMapper; } - public IEnumerable MapFrom(IEnumerable parameterBuilders, SimulationConfiguration simulationConfiguration, params ParameterBuildMode[] parameterBuildModesToMap) + public IEnumerable MapFrom(IEnumerable parameterBuilders, SimulationBuilder simulationBuilder, params ParameterBuildMode[] parameterBuildModesToMap) { return parameterBuilders.Where(p => canBeMapped(p, parameterBuildModesToMap)) - .Select(parameterBuilder => _parameterMapper.MapFrom(parameterBuilder, simulationConfiguration)).ToList(); + .Select(parameterBuilder => _parameterMapper.MapFrom(parameterBuilder, simulationBuilder)).ToList(); } - public IEnumerable MapFrom(IContainer container, SimulationConfiguration simulationConfiguration, params ParameterBuildMode[] parameterBuildModesToMap) + public IEnumerable MapFrom(IContainer container, SimulationBuilder simulationBuilder, params ParameterBuildMode[] parameterBuildModesToMap) { - return MapFrom(container.GetChildren(), simulationConfiguration, parameterBuildModesToMap); + return MapFrom(container.GetChildren(), simulationBuilder, parameterBuildModesToMap); } - public IEnumerable MapGlobalOrPropertyFrom(IContainer container, SimulationConfiguration simulationConfiguration) + public IEnumerable MapGlobalOrPropertyFrom(IContainer container, SimulationBuilder simulationBuilder) { - return MapFrom(container, simulationConfiguration, ParameterBuildMode.Global, ParameterBuildMode.Property); + return MapFrom(container, simulationBuilder, ParameterBuildMode.Global, ParameterBuildMode.Property); } - public IEnumerable MapLocalFrom(IContainer container, SimulationConfiguration simulationConfiguration) + public IEnumerable MapLocalFrom(IContainer container, SimulationBuilder simulationBuilder) { - return MapFrom(container, simulationConfiguration, ParameterBuildMode.Local); + return MapFrom(container, simulationBuilder, ParameterBuildMode.Local); } - public IEnumerable MapAllFrom(IContainer container, SimulationConfiguration simulationConfiguration) + public IEnumerable MapAllFrom(IContainer container, SimulationBuilder simulationBuilder) { - return MapFrom(container, simulationConfiguration); + return MapFrom(container, simulationBuilder); } private bool canBeMapped(IParameter parameter, params ParameterBuildMode[] parameterBuildModesToMap) diff --git a/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderToParameterMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderToParameterMapper.cs index 7dfb30190..5f5183ac5 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderToParameterMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ParameterBuilderToParameterMapper.cs @@ -7,7 +7,7 @@ public interface IParameterBuilderToParameterMapper : IBuilderMapper() .WithName(Constants.Parameters.PROCESS_RATE) .WithDimension(processBuilder.Dimension) - .WithFormula(_formulaMapper.MapFrom(processBuilder.Formula, simulationConfiguration)); + .WithFormula(_formulaMapper.MapFrom(processBuilder.Formula, simulationBuilder)); parameter.Visible = false; parameter.Editable = false; @@ -34,7 +34,7 @@ public IParameter CreateProcessRateParameterFor(IProcessBuilder processBuilder, addAdditionalParentReference(parameter.Formula); - simulationConfiguration.AddBuilderReference(parameter, processBuilder); + simulationBuilder.AddBuilderReference(parameter, processBuilder); if (processBuilder.ProcessRateParameterPersistable) parameter.Persistable = true; diff --git a/src/OSPSuite.Core/Domain/Mappers/ReactionBuilderToReactionMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ReactionBuilderToReactionMapper.cs index 14a2656a9..8bad65ab9 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ReactionBuilderToReactionMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ReactionBuilderToReactionMapper.cs @@ -32,35 +32,35 @@ public ReactionBuilderToReactionMapper(IObjectBaseFactory objectBaseFactory, _processRateParameterCreator = processRateParameterCreator; } - public IReaction MapFromLocal(IReactionBuilder reactionBuilder, IContainer container, SimulationConfiguration simulationConfiguration) + public IReaction MapFromLocal(IReactionBuilder reactionBuilder, IContainer container, SimulationBuilder simulationBuilder) { var reaction = _objectBaseFactory.Create() .WithName(reactionBuilder.Name) .WithDescription(reactionBuilder.Description) .WithIcon(reactionBuilder.Icon) .WithDimension(reactionBuilder.Dimension) - .WithFormula(createReactionKinetic(reactionBuilder, simulationConfiguration)); - reactionBuilder.Educts.Each(reactionPartnerBuilder => reaction.AddEduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, simulationConfiguration))); - reactionBuilder.Products.Each(reactionPartnerBuilder => reaction.AddProduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, simulationConfiguration))); + .WithFormula(createReactionKinetic(reactionBuilder, simulationBuilder)); + reactionBuilder.Educts.Each(reactionPartnerBuilder => reaction.AddEduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, simulationBuilder))); + reactionBuilder.Products.Each(reactionPartnerBuilder => reaction.AddProduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, simulationBuilder))); reactionBuilder.ModifierNames.Each(reaction.AddModifier); - reaction.AddChildren(_parameterMapper.MapLocalFrom(reactionBuilder, simulationConfiguration)); + reaction.AddChildren(_parameterMapper.MapLocalFrom(reactionBuilder, simulationBuilder)); if (reactionBuilder.CreateProcessRateParameter) - reaction.Add(processRateParameterFor(reactionBuilder, simulationConfiguration)); + reaction.Add(processRateParameterFor(reactionBuilder, simulationBuilder)); - simulationConfiguration.AddBuilderReference(reaction, reactionBuilder); + simulationBuilder.AddBuilderReference(reaction, reactionBuilder); return reaction; } - private IFormula createReactionKinetic(IReactionBuilder reactionBuilder, SimulationConfiguration simulationConfiguration) + private IFormula createReactionKinetic(IReactionBuilder reactionBuilder, SimulationBuilder simulationBuilder) { - return _formulaMapper.MapFrom(reactionBuilder.Formula, simulationConfiguration); + return _formulaMapper.MapFrom(reactionBuilder.Formula, simulationBuilder); } - private IParameter processRateParameterFor(IReactionBuilder reactionBuilder, SimulationConfiguration simulationConfiguration) + private IParameter processRateParameterFor(IReactionBuilder reactionBuilder, SimulationBuilder simulationBuilder) { - return _processRateParameterCreator.CreateProcessRateParameterFor(reactionBuilder, simulationConfiguration); + return _processRateParameterCreator.CreateProcessRateParameterFor(reactionBuilder, simulationBuilder); } } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Mappers/ReactionPartnerBuilderToReactionPartnerMapper.cs b/src/OSPSuite.Core/Domain/Mappers/ReactionPartnerBuilderToReactionPartnerMapper.cs index f5ac625c1..45efdb32c 100644 --- a/src/OSPSuite.Core/Domain/Mappers/ReactionPartnerBuilderToReactionPartnerMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/ReactionPartnerBuilderToReactionPartnerMapper.cs @@ -8,7 +8,7 @@ public interface IReactionPartnerBuilderToReactionPartnerMapper : ILocalMapper /// - public class ReactionPartnerBuilderToReactionPartnerMapper : IReactionPartnerBuilderToReactionPartnerMapper + internal class ReactionPartnerBuilderToReactionPartnerMapper : IReactionPartnerBuilderToReactionPartnerMapper { /// /// Maps from input to output using data provided by local. @@ -18,8 +18,8 @@ public class ReactionPartnerBuilderToReactionPartnerMapper : IReactionPartnerBui /// The container there we found used molecules amounts in, should be normally the same as there /// the reaction is created /// - /// simulation configuration used to create model - public IReactionPartner MapFromLocal(IReactionPartnerBuilder reactionPartnerBuilder, IContainer container, SimulationConfiguration simulationConfiguration) + /// Simulation Builder + public IReactionPartner MapFromLocal(IReactionPartnerBuilder reactionPartnerBuilder, IContainer container, SimulationBuilder simulationBuilder) { var moleculeAmount = container.GetSingleChildByName(reactionPartnerBuilder.MoleculeName); if (moleculeAmount == null) diff --git a/src/OSPSuite.Core/Domain/Mappers/TransportBuilderToTransportMapper.cs b/src/OSPSuite.Core/Domain/Mappers/TransportBuilderToTransportMapper.cs index 33cf5f9de..73d2c9d40 100644 --- a/src/OSPSuite.Core/Domain/Mappers/TransportBuilderToTransportMapper.cs +++ b/src/OSPSuite.Core/Domain/Mappers/TransportBuilderToTransportMapper.cs @@ -7,14 +7,14 @@ namespace OSPSuite.Core.Domain.Mappers /// /// Mapper for the creation of a Transport in the model from . /// - public interface ITransportBuilderToTransportMapper : IBuilderMapper + internal interface ITransportBuilderToTransportMapper : IBuilderMapper { } /// /// Mapper for the creation of a Transport in the model from . /// - public class TransportBuilderToTransportMapper : ITransportBuilderToTransportMapper + internal class TransportBuilderToTransportMapper : ITransportBuilderToTransportMapper { private readonly IObjectBaseFactory _objectBaseFactory; private readonly IFormulaBuilderToFormulaMapper _formulaMapper; @@ -32,33 +32,33 @@ public TransportBuilderToTransportMapper(IObjectBaseFactory objectBaseFactory, _processRateParameterCreator = processRateParameterCreator; } - public ITransport MapFrom(ITransportBuilder transportBuilder, SimulationConfiguration simulationConfiguration) + public ITransport MapFrom(ITransportBuilder transportBuilder, SimulationBuilder simulationBuilder) { var transport = _objectBaseFactory.Create() .WithName(transportBuilder.Name) .WithIcon(transportBuilder.Icon) .WithDimension(transportBuilder.Dimension) - .WithFormula(_formulaMapper.MapFrom(transportBuilder.Formula, simulationConfiguration)); + .WithFormula(_formulaMapper.MapFrom(transportBuilder.Formula, simulationBuilder)); - simulationConfiguration.AddBuilderReference(transport, transportBuilder); + simulationBuilder.AddBuilderReference(transport, transportBuilder); - addLocalParameters(transport, transportBuilder, simulationConfiguration); + addLocalParameters(transport, transportBuilder, simulationBuilder); //lastly, add parameter rate transporter if required if (transportBuilder.CreateProcessRateParameter) - transport.Add(processRateParameterFor(transportBuilder, simulationConfiguration)); + transport.Add(processRateParameterFor(transportBuilder, simulationBuilder)); return transport; } - private void addLocalParameters(ITransport transport, ITransportBuilder transportBuilder, SimulationConfiguration simulationConfiguration) + private void addLocalParameters(ITransport transport, ITransportBuilder transportBuilder, SimulationBuilder simulationBuilder) { - transport.AddChildren(_parameterMapper.MapLocalFrom(transportBuilder, simulationConfiguration)); + transport.AddChildren(_parameterMapper.MapLocalFrom(transportBuilder, simulationBuilder)); } - private IParameter processRateParameterFor(ITransportBuilder transportBuilder, SimulationConfiguration simulationConfiguration) + private IParameter processRateParameterFor(ITransportBuilder transportBuilder, SimulationBuilder simulationBuilder) { - var parameter = _processRateParameterCreator.CreateProcessRateParameterFor(transportBuilder, simulationConfiguration); + var parameter = _processRateParameterCreator.CreateProcessRateParameterFor(transportBuilder, simulationBuilder); parameter.AddTag(ObjectPathKeywords.MOLECULE); parameter.AddTag(ObjectPathKeywords.NEIGHBORHOOD); diff --git a/src/OSPSuite.Core/Domain/Model.cs b/src/OSPSuite.Core/Domain/Model.cs index cbd413e4f..4852c904f 100644 --- a/src/OSPSuite.Core/Domain/Model.cs +++ b/src/OSPSuite.Core/Domain/Model.cs @@ -1,4 +1,6 @@ -using OSPSuite.Core.Domain.Services; +using System.Collections.Generic; +using System.Linq; +using OSPSuite.Core.Domain.Services; using OSPSuite.Core.Extensions; using OSPSuite.Utility.Visitor; @@ -33,6 +35,11 @@ public interface IModel : IObjectBase, IMolWeightFinder /// 3-Otherwise, returns an empty string /// string MoleculeNameFor(IEntity entity); + + /// + /// returns the name of all molecule present in the model; + /// + IReadOnlyList AllPresentMoleculeNames { get; } } public class Model : ObjectBase, IModel @@ -82,6 +89,8 @@ public string MoleculeNameFor(IEntity entity) return MoleculeNameFor(entity.ParentContainer); } + public IReadOnlyList AllPresentMoleculeNames => Root?.GetChildren(x => x.ContainerType == ContainerType.Molecule).AllNames(); + public double? MolWeightFor(string quantityPath) { var pathArray = quantityPath.ToPathArray(); diff --git a/src/OSPSuite.Core/Domain/ModelCoreSimulation.cs b/src/OSPSuite.Core/Domain/ModelCoreSimulation.cs index 7d18b04bf..7f8a57b0e 100644 --- a/src/OSPSuite.Core/Domain/ModelCoreSimulation.cs +++ b/src/OSPSuite.Core/Domain/ModelCoreSimulation.cs @@ -26,7 +26,7 @@ public interface IModelCoreSimulation : IObjectBase, IWithCreationMetaData, IWit /// The reactions used to create the simulation. This is only use as meta information /// on model creation for now. Adding to the building block will not change the model structure /// - IReadOnlyCollection Reactions { get; } + IReadOnlyCollection Reactions { get; } /// /// Name of all compounds used in the simulation @@ -59,9 +59,9 @@ public class ModelCoreSimulation : ObjectBase, IModelCoreSimulation public SimulationSettings Settings => Configuration?.SimulationSettings; - public IReadOnlyCollection Reactions => Configuration?.Reactions; + public IReadOnlyCollection Reactions => Configuration?.All(); - public IReadOnlyList CompoundNames => Configuration?.AllPresentMolecules().AllNames(); + public IReadOnlyList CompoundNames => Model?.AllPresentMoleculeNames; public IEnumerable All() where T : class, IEntity => Model?.Root.GetAllChildren().Union(allFromSettings()) ?? Enumerable.Empty(); diff --git a/src/OSPSuite.Core/Domain/ModelCoreSimulationExtensions.cs b/src/OSPSuite.Core/Domain/ModelCoreSimulationExtensions.cs index dc72eda8b..e55f2fcf1 100644 --- a/src/OSPSuite.Core/Domain/ModelCoreSimulationExtensions.cs +++ b/src/OSPSuite.Core/Domain/ModelCoreSimulationExtensions.cs @@ -39,7 +39,9 @@ private static IReadOnlyList allApplicationsForMolecule(IModelCoreSi var allApplications = applicationEventGroup.SelectMany(x => x.GetAllChildren(c => c.ContainerType == ContainerType.Application)) .ToList(); - return getApplicationsForAppliedAncestorMolecule(simulation.Reactions, moleculeName, allApplications, new List()); + var reactionCache = new ObjectBaseCache(); + reactionCache.AddRange(simulation.Reactions.SelectMany(x => x)); + return getApplicationsForAppliedAncestorMolecule(reactionCache, moleculeName, allApplications, new List()); } private static IReadOnlyList getApplicationsForAppliedAncestorMolecule(IEnumerable reactions, string moleculeName, diff --git a/src/OSPSuite.Core/Domain/Module.cs b/src/OSPSuite.Core/Domain/Module.cs index 33d07724b..2989309df 100644 --- a/src/OSPSuite.Core/Domain/Module.cs +++ b/src/OSPSuite.Core/Domain/Module.cs @@ -16,12 +16,12 @@ public class Module : ObjectBase public bool ReadOnly { get; set; } = false; + public IEventGroupBuildingBlock EventGroups { set; get; } public MoleculeBuildingBlock Molecules { set; get; } + public IObserverBuildingBlock Observers { set; get; } public IReactionBuildingBlock Reactions { set; get; } public IPassiveTransportBuildingBlock PassiveTransports { set; get; } public ISpatialStructure SpatialStructure { set; get; } - public IObserverBuildingBlock Observers { set; get; } - public IEventGroupBuildingBlock EventGroups { set; get; } public IReadOnlyList MoleculeStartValuesCollection => _moleculeStartValuesCollection; public IReadOnlyList ParameterStartValuesCollection => _parameterStartValuesCollection; public virtual ExtendedProperties ExtendedProperties { get; } = new ExtendedProperties(); @@ -103,26 +103,26 @@ public void AddBuildingBlock(IBuildingBlock buildingBlock) } } - public void RemoveBuildingBlock( IBuildingBlock buildingBlock) + public void RemoveBuildingBlock(IBuildingBlock buildingBlock) { switch (buildingBlock) { - case MoleculeBuildingBlock molecule: + case MoleculeBuildingBlock _: Molecules = null; break; - case IReactionBuildingBlock reaction: + case IReactionBuildingBlock _: Reactions = null; break; - case ISpatialStructure spatialStructure: + case ISpatialStructure _: SpatialStructure = null; break; - case IPassiveTransportBuildingBlock passiveTransport: + case IPassiveTransportBuildingBlock _: PassiveTransports = null; break; - case IEventGroupBuildingBlock eventGroup: + case IEventGroupBuildingBlock _: EventGroups = null; break; - case IObserverBuildingBlock observer: + case IObserverBuildingBlock _: Observers = null; break; case ParameterStartValuesBuildingBlock parameterStartValues: @@ -172,7 +172,7 @@ public override void AcceptVisitor(IVisitor visitor) public void AddExtendedProperty(string propertyName, T property) { - ExtendedProperties[propertyName] = new ExtendedProperty { Name = propertyName, Value = property }; + ExtendedProperties[propertyName] = new ExtendedProperty {Name = propertyName, Value = property}; } /// diff --git a/src/OSPSuite.Core/Domain/ModuleConfiguration.cs b/src/OSPSuite.Core/Domain/ModuleConfiguration.cs index 9e6f25f9c..56733c741 100644 --- a/src/OSPSuite.Core/Domain/ModuleConfiguration.cs +++ b/src/OSPSuite.Core/Domain/ModuleConfiguration.cs @@ -24,16 +24,57 @@ public ModuleConfiguration() { } - public ModuleConfiguration(Module module, MoleculeStartValuesBuildingBlock selectedMoleculeStartValueBuilding = null, ParameterStartValuesBuildingBlock selectedParameterStartValues = null) + /// + /// Create a new module configuration for the given module and will assign the first molecule and parameter start values + /// if defined + /// + /// Module + public ModuleConfiguration(Module module) : this(module, module.MoleculeStartValuesCollection.FirstOrDefault(), module.ParameterStartValuesCollection.FirstOrDefault()) { Module = module; - SelectedMoleculeStartValues = selectedMoleculeStartValueBuilding ?? module.MoleculeStartValuesCollection.FirstOrDefault(); - SelectedParameterStartValues = selectedParameterStartValues ?? module.ParameterStartValuesCollection.FirstOrDefault(); + } + + /// + /// Create a new module configuration for the given module and the selected molecule and parameter start values + /// + /// Module + /// molecule start values. Assuming this belongs to the module or is null + /// parameter start values. Assuming this belongs to the module or is null + public ModuleConfiguration(Module module, MoleculeStartValuesBuildingBlock selectedMoleculeStartValueBuilding, ParameterStartValuesBuildingBlock selectedParameterStartValues) + { + Module = module; + SelectedMoleculeStartValues = selectedMoleculeStartValueBuilding; + SelectedParameterStartValues = selectedParameterStartValues; } public void AcceptVisitor(IVisitor visitor) { Module.AcceptVisitor(visitor); } + + public T BuildingBlock() where T : class, IBuildingBlock + { + switch (typeof(T)) + { + case Type eventType when eventType == typeof(EventGroupBuildingBlock): + return Module.EventGroups as T; + case Type moleculeType when moleculeType == typeof(MoleculeBuildingBlock): + return Module.Molecules as T; + case Type observerType when observerType == typeof(ObserverBuildingBlock): + return Module.Observers as T; + case Type reactionType when reactionType == typeof(ReactionBuildingBlock): + return Module.Reactions as T; + case Type transportType when transportType == typeof(PassiveTransportBuildingBlock): + return Module.PassiveTransports as T; + case Type spStrType when spStrType == typeof(SpatialStructure): + return Module.SpatialStructure as T; + case Type molStartValuesType when molStartValuesType == typeof(MoleculeStartValuesBuildingBlock): + return SelectedMoleculeStartValues as T; + case Type paramStartValuesType when paramStartValuesType == typeof(ParameterStartValuesBuildingBlock): + return SelectedParameterStartValues as T; + default: + return null; + } + } } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Services/CalculationMethodTask.cs b/src/OSPSuite.Core/Domain/Services/CalculationMethodTask.cs index ce128232b..4232e5315 100644 --- a/src/OSPSuite.Core/Domain/Services/CalculationMethodTask.cs +++ b/src/OSPSuite.Core/Domain/Services/CalculationMethodTask.cs @@ -11,12 +11,12 @@ namespace OSPSuite.Core.Domain.Services { - public interface ICalculationMethodTask + internal interface ICalculationMethodTask { void MergeCalculationMethodInModel(ModelConfiguration modelConfiguration); } - public class CalculationMethodTask : ICalculationMethodTask + internal class CalculationMethodTask : ICalculationMethodTask { private readonly IFormulaTask _formulaTask; private readonly IKeywordReplacerTask _keywordReplacerTask; @@ -27,6 +27,7 @@ public class CalculationMethodTask : ICalculationMethodTask private IList _allBlackBoxParameters; private IModel _model; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; public CalculationMethodTask( IFormulaTask formulaTask, @@ -46,12 +47,12 @@ public void MergeCalculationMethodInModel(ModelConfiguration modelConfiguration) { try { - (_model, _simulationConfiguration) = modelConfiguration; + (_model, _simulationConfiguration, _simulationBuilder ) = modelConfiguration; _allContainers = _model.Root.GetAllContainersAndSelf().ToEntityDescriptorMapList(); _allBlackBoxParameters = _model.Root.GetAllChildren().Where(p => p.Formula.IsBlackBox()).ToList(); foreach (var calculationMethod in _simulationConfiguration.AllCalculationMethods) { - var allMoleculesUsingMethod = allMoleculesUsing(calculationMethod, _simulationConfiguration.Molecules).ToList(); + var allMoleculesUsingMethod = allMoleculesUsing(calculationMethod, _simulationBuilder.Molecules).ToList(); createFormulaForBlackBoxParameters(calculationMethod, allMoleculesUsingMethod); @@ -61,6 +62,7 @@ public void MergeCalculationMethodInModel(ModelConfiguration modelConfiguration) finally { _simulationConfiguration = null; + _simulationBuilder = null; _allContainers.Clear(); _allBlackBoxParameters.Clear(); _model = null; @@ -80,7 +82,7 @@ private void addHelpParametersFor(ICoreCalculationMethod calculationMethod, ILis //does not exist yet if (existingParameter == null) { - var parameter = _parameterMapper.MapFrom(helpParameter, _simulationConfiguration); + var parameter = _parameterMapper.MapFrom(helpParameter, _simulationBuilder); container.Add(parameter); replaceKeyWordsIn(parameter, molecule.Name); } @@ -107,7 +109,7 @@ private void createFormulaForBlackBoxParameters(ICoreCalculationMethod calculati //parameter formula was not set yet if (parameter.Formula.IsBlackBox()) { - parameter.Formula = _formulaMapper.MapFrom(formula, _simulationConfiguration); + parameter.Formula = _formulaMapper.MapFrom(formula, _simulationBuilder); replaceKeyWordsIn(parameter, molecule.Name); } else @@ -144,7 +146,7 @@ private bool formulasAreTheSameForParameter(IParameter originalParameter, IFormu { var previousFormula = originalParameter.Formula; //needs to use the parameter in order to keep the hierarchy. Hence we set the formula in the parameter - originalParameter.Formula = _formulaMapper.MapFrom(calculationMethodFormula, _simulationConfiguration); + originalParameter.Formula = _formulaMapper.MapFrom(calculationMethodFormula, _simulationBuilder); //check if the formula set are the same. it is necessary to replace keywords before doing that replaceKeyWordsIn(originalParameter, moleculeName); diff --git a/src/OSPSuite.Core/Domain/Services/EventBuilderTask.cs b/src/OSPSuite.Core/Domain/Services/EventBuilderTask.cs index 49ea08d01..f03ecc7a5 100644 --- a/src/OSPSuite.Core/Domain/Services/EventBuilderTask.cs +++ b/src/OSPSuite.Core/Domain/Services/EventBuilderTask.cs @@ -14,7 +14,7 @@ namespace OSPSuite.Core.Domain.Services /// /// Creates events in model using events-building block configuration /// - public interface IEventBuilderTask + internal interface IEventBuilderTask { /// /// Adds events defined by build configuration to the given model @@ -31,7 +31,7 @@ internal class EventBuilderTask : IEventBuilderTask private EntityDescriptorMapList _allModelContainerDescriptors; private ICache> _sourceCriteriaTargetContainerCache; private ICache> _applicationTransportTargetContainerCache; - private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; public EventBuilderTask( IKeywordReplacerTask keywordReplacerTask, @@ -47,14 +47,14 @@ public void CreateEvents(ModelConfiguration modelConfiguration) { try { - (_model, _simulationConfiguration) = modelConfiguration; + (_model, _simulationBuilder) = modelConfiguration; _allModelContainerDescriptors = _model.Root.GetAllContainersAndSelf().ToEntityDescriptorMapList(); _sourceCriteriaTargetContainerCache = new Cache>(); _applicationTransportTargetContainerCache = new Cache>(); //Cache all containers where the event group builder will be created using the source criteria - foreach (var eventGroupBuilder in _simulationConfiguration.EventGroups) + foreach (var eventGroupBuilder in _simulationBuilder.EventGroups) { if (_sourceCriteriaTargetContainerCache.Contains(eventGroupBuilder.SourceCriteria)) continue; @@ -62,7 +62,7 @@ public void CreateEvents(ModelConfiguration modelConfiguration) _sourceCriteriaTargetContainerCache.Add(eventGroupBuilder.SourceCriteria, _allModelContainerDescriptors.AllSatisfiedBy(eventGroupBuilder.SourceCriteria)); } - _simulationConfiguration.EventGroups.Each(createEventGroupFrom); + _simulationBuilder.EventGroups.Each(createEventGroupFrom); } finally { @@ -72,7 +72,7 @@ public void CreateEvents(ModelConfiguration modelConfiguration) _sourceCriteriaTargetContainerCache = null; _applicationTransportTargetContainerCache.Clear(); _applicationTransportTargetContainerCache = null; - _simulationConfiguration = null; + _simulationBuilder = null; } } @@ -93,13 +93,13 @@ private void createEventGroupFrom(IEventGroupBuilder eventGroupBuilder) private void createEventGroupInContainer(IEventGroupBuilder eventGroupBuilder, IContainer sourceContainer) { //this creates recursively all event groups for the given builder - var eventGroup = _eventGroupMapper.MapFrom(eventGroupBuilder, _simulationConfiguration); + var eventGroup = _eventGroupMapper.MapFrom(eventGroupBuilder, _simulationBuilder); sourceContainer.Add(eventGroup); //needs to add the requires transport into model only for the added event group foreach (var childEventGroup in eventGroup.GetAllContainersAndSelf()) { - var childEventGroupBuilder = _simulationConfiguration.BuilderFor(childEventGroup).DowncastTo(); + var childEventGroupBuilder = _simulationBuilder.BuilderFor(childEventGroup).DowncastTo(); if (childEventGroupBuilder is IApplicationBuilder applicationBuilder) addApplicationTransports(applicationBuilder, childEventGroup); @@ -137,7 +137,7 @@ private void addApplicationTransportToModel(ITransportBuilder appTransport, Enti if (targetAmount == null) throw new OSPSuiteException(Validation.CannotCreateApplicationTargetNotFound(appTransport.Name, moleculeName, targetContainer.Name)); - var transport = _transportMapper.MapFrom(appTransport, _simulationConfiguration); + var transport = _transportMapper.MapFrom(appTransport, _simulationBuilder); transport.SourceAmount = sourceAmount; transport.TargetAmount = targetAmount; diff --git a/src/OSPSuite.Core/Domain/Services/IModelValidatorFactory.cs b/src/OSPSuite.Core/Domain/Services/IModelValidatorFactory.cs index 3087aede3..3f437699f 100644 --- a/src/OSPSuite.Core/Domain/Services/IModelValidatorFactory.cs +++ b/src/OSPSuite.Core/Domain/Services/IModelValidatorFactory.cs @@ -2,7 +2,7 @@ namespace OSPSuite.Core.Domain.Services { - public interface IModelValidatorFactory + internal interface IModelValidatorFactory { T Create() where T : IModelValidator; } diff --git a/src/OSPSuite.Core/Domain/Services/ModelConstructor.cs b/src/OSPSuite.Core/Domain/Services/ModelConstructor.cs index eb2448a9f..559f6eca9 100644 --- a/src/OSPSuite.Core/Domain/Services/ModelConstructor.cs +++ b/src/OSPSuite.Core/Domain/Services/ModelConstructor.cs @@ -82,37 +82,35 @@ public ModelConstructor( public CreationResult CreateModelFrom(SimulationConfiguration simulationConfiguration, string modelName) { - using (new SimulationConfigurationDisposer(simulationConfiguration)) - { - var model = _objectBaseFactory.Create().WithName(modelName); - var modelConfiguration = new ModelConfiguration(model, simulationConfiguration); - var creationResult = buildProcess(modelConfiguration, - //One function per process step - checkSimulationConfiguration, - createModelStructure, - validateModelName, - createProcesses, - createObserversAndEvents, - setQuantitiesValues); - - if (creationResult.State == ValidationState.Invalid) - return creationResult; + var model = _objectBaseFactory.Create().WithName(modelName); + var simulationBuilder = new SimulationBuilder(simulationConfiguration); + var modelConfiguration = new ModelConfiguration(model, simulationConfiguration, simulationBuilder); + var creationResult = buildProcess(modelConfiguration, + //One function per process step + checkSimulationConfiguration, + createModelStructure, + validateModelName, + createProcesses, + createObserversAndEvents, + setQuantitiesValues); + + if (creationResult.State == ValidationState.Invalid) + return creationResult; - //replace all keywords define in the model structure once all build processes have been executed - _keywordReplacerTask.ReplaceIn(model.Root); + //replace all keywords define in the model structure once all build processes have been executed + _keywordReplacerTask.ReplaceIn(model.Root); - //This needs to be done before we validate the model to ensure that all references can be found - _formulaTask.ExpandNeighborhoodReferencesIn(model); + //This needs to be done before we validate the model to ensure that all references can be found + _formulaTask.ExpandNeighborhoodReferencesIn(model); - creationResult.Add(validateModel(modelConfiguration)); + creationResult.Add(validateModel(modelConfiguration)); - if (creationResult.State == ValidationState.Invalid) - return creationResult; + if (creationResult.State == ValidationState.Invalid) + return creationResult; - finalizeModel(model); + finalizeModel(model); - return creationResult; - } + return creationResult; } private void finalizeModel(IModel model) @@ -147,15 +145,13 @@ private ValidationResult validateModel(ModelConfiguration modelConfiguration) if (!modelConfiguration.ShouldValidate) return new ValidationResult(); - var (_, simulationConfiguration) = modelConfiguration; - //Validation needs to happen at the very end of the process var reactionAndTransportValidation = validate(modelConfiguration); var observersAndEventsValidation = validate(modelConfiguration); var modelValidation = validate(modelConfiguration); var validation = new ValidationResult(reactionAndTransportValidation, observersAndEventsValidation, modelValidation); - if (!simulationConfiguration.PerformCircularReferenceCheck) + if (!modelConfiguration.SimulationConfiguration.PerformCircularReferenceCheck) return validation; var circularReferenceValidation = checkCircularReferences(modelConfiguration); @@ -165,13 +161,12 @@ private ValidationResult validateModel(ModelConfiguration modelConfiguration) private CreationResult buildProcess(ModelConfiguration modelConfiguration, params Func[] steps) { - var (model, simulationConfiguration) = modelConfiguration; - var result = new CreationResult(model); + var result = new CreationResult(modelConfiguration.Model, modelConfiguration.SimulationBuilder); IProgressUpdater progress = null; try { - if (simulationConfiguration.ShowProgress) + if (modelConfiguration.SimulationConfiguration.ShowProgress) { progress = _progressManager.Create(); progress.Initialize(steps.Length, Messages.CreatingModel); @@ -199,11 +194,10 @@ private CreationResult buildProcess(ModelConfiguration modelConfiguration, private ValidationResult checkSimulationConfiguration(ModelConfiguration modelConfiguration) { - var (_, simulationConfiguration) = modelConfiguration; if (!modelConfiguration.ShouldValidate) return new ValidationResult(); - return _simulationConfigurationValidator.Validate(simulationConfiguration); + return _simulationConfigurationValidator.Validate(modelConfiguration.SimulationConfiguration); } private ValidationResult createModelStructure(ModelConfiguration modelConfiguration) @@ -305,7 +299,7 @@ private ValidationResult setQuantitiesValues(ModelConfiguration modelConfigurati private void createPassiveTransports(ModelConfiguration modelConfiguration) { - modelConfiguration.SimulationConfiguration.PassiveTransports.Each(t => _transportCreator.CreatePassiveTransport(t, modelConfiguration)); + modelConfiguration.SimulationBuilder.PassiveTransports.Each(t => _transportCreator.CreatePassiveTransport(t, modelConfiguration)); } private IEnumerable createReactions(ModelConfiguration modelConfiguration) @@ -314,7 +308,7 @@ private IEnumerable createReactions(ModelConfiguration modelC var messages = simulationConfiguration.Reactions .Where(x => !_reactionCreator.CreateReaction(x, modelConfiguration)) .Select( - x => new ValidationMessage(NotificationType.Warning, Validation.WarningNoReactionCreated(x.Name),x, x.BuildingBlock)) + x => new ValidationMessage(NotificationType.Warning, Validation.WarningNoReactionCreated(x.Name), x, x.BuildingBlock)) .ToList(); model.Root.GetAllContainersAndSelf(x => x.ContainerType == ContainerType.Reaction) @@ -377,13 +371,13 @@ private void addLocalStructureMoleculeParametersToMoleculeAmount(IEnumerable createMoleculeAmounts(ModelConfiguration modelConfiguration) { - var (_, simulationConfiguration) = modelConfiguration; + var (_, simulationBuilder) = modelConfiguration; var presentMolecules = allPresentMoleculesInContainers(modelConfiguration).ToList(); var moleculesWithPhysicalContainers = presentMolecules.Where(containerIsPhysical); - moleculesWithPhysicalContainers.Each(x => { addMoleculeToContainer(simulationConfiguration, x.Container, simulationConfiguration.MoleculeByName(x.MoleculeStartValue.MoleculeName)); }); + moleculesWithPhysicalContainers.Each(x => { addMoleculeToContainer(simulationBuilder, x.Container, simulationBuilder.MoleculeByName(x.MoleculeStartValue.MoleculeName)); }); - return new MoleculeBuildingBlockValidator().Validate(simulationConfiguration.Molecules).Messages.Concat(createValidationMessagesForPresentMolecules(presentMolecules)); + return new MoleculeBuildingBlockValidator().Validate(simulationBuilder.Molecules).Messages.Concat(createValidationMessagesForPresentMolecules(presentMolecules)); } private static bool containerIsPhysical(StartValueAndContainer startValueAndContainer) @@ -391,9 +385,9 @@ private static bool containerIsPhysical(StartValueAndContainer startValueAndCont return startValueAndContainer.Container != null && startValueAndContainer.Container.Mode == ContainerMode.Physical; } - private void addMoleculeToContainer(SimulationConfiguration simulationConfiguration, IContainer container, IMoleculeBuilder moleculeBuilder) + private void addMoleculeToContainer(SimulationBuilder simulationBuilder, IContainer container, IMoleculeBuilder moleculeBuilder) { - container.Add(_moleculeMapper.MapFrom(moleculeBuilder, container, simulationConfiguration)); + container.Add(_moleculeMapper.MapFrom(moleculeBuilder, container, simulationBuilder)); } private IEnumerable createValidationMessagesForPresentMolecules(List presentMolecules) diff --git a/src/OSPSuite.Core/Domain/Services/ModelValidator.cs b/src/OSPSuite.Core/Domain/Services/ModelValidator.cs index c3ea044c3..844967b1e 100644 --- a/src/OSPSuite.Core/Domain/Services/ModelValidator.cs +++ b/src/OSPSuite.Core/Domain/Services/ModelValidator.cs @@ -20,7 +20,7 @@ internal enum ResolveErrorBehavior Delete } - public interface IModelValidator + internal interface IModelValidator { ValidationResult Validate(ModelConfiguration modelConfiguration); } @@ -33,7 +33,7 @@ internal abstract class ModelValidator : IModelValidator, IVisitor private readonly IObjectTypeResolver _objectTypeResolver; private readonly IObjectPathFactory _objectPathFactory; private readonly IEnumerable _keywords; - private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; private ValidationResult _result; protected ModelValidator(IObjectTypeResolver objectTypeResolver, IObjectPathFactory objectPathFactory) @@ -64,7 +64,7 @@ protected void CheckParameter(IParameter parameterToCheck, ResolveErrorBehavior protected void CheckFormulaIn(IUsingFormula entity, IFormula formulaToCheck, ResolveErrorBehavior resolveErrorBehavior) { var entityAbsolutePath = _objectPathFactory.CreateAbsoluteObjectPath(entity).ToPathString(); - var builder = _simulationConfiguration.BuilderFor(entity); + var builder = _simulationBuilder.BuilderFor(entity); var objectWithError = builder ?? entity; // Dynamic formula may contain object path that will be resolved per instance. It cannot be checked here @@ -86,7 +86,7 @@ protected void CheckFormulaIn(IUsingFormula entity, IFormula formulaToCheck, Res protected void CheckPath(IUsingFormula entity, ObjectPath objectPathToCheck, ResolveErrorBehavior resolveErrorBehavior) { - var builder = _simulationConfiguration.BuilderFor(entity); + var builder = _simulationBuilder.BuilderFor(entity); var objectWithError = builder ?? entity; var entityAbsolutePath = _objectPathFactory.CreateAbsoluteObjectPath(entity).ToString(); var entityType = _objectTypeResolver.TypeFor(entity); @@ -131,15 +131,15 @@ public ValidationResult Validate(ModelConfiguration modelConfiguration) { try { - var (model, simulationConfiguration) = modelConfiguration; + var (model, simulationBuilder) = modelConfiguration; _result = new ValidationResult(); - _simulationConfiguration = simulationConfiguration; + _simulationBuilder = simulationBuilder; model.AcceptVisitor(this); return _result; } finally { - _simulationConfiguration = null; + _simulationBuilder = null; _result = null; } } diff --git a/src/OSPSuite.Core/Domain/Services/MoleculePropertiesContainerTask.cs b/src/OSPSuite.Core/Domain/Services/MoleculePropertiesContainerTask.cs index 02685d83f..97ab70d83 100644 --- a/src/OSPSuite.Core/Domain/Services/MoleculePropertiesContainerTask.cs +++ b/src/OSPSuite.Core/Domain/Services/MoleculePropertiesContainerTask.cs @@ -6,7 +6,7 @@ namespace OSPSuite.Core.Domain.Services { - public interface IMoleculePropertiesContainerTask + internal interface IMoleculePropertiesContainerTask { /// /// Retrieves the sub container in the neighborhood whose name is equal to the name of the given molecule. @@ -20,13 +20,14 @@ public interface IMoleculePropertiesContainerTask /// Creates the global molecule container for the molecule and add parameters with the build modes other than "Local" /// into the created molecule container /// - IContainer CreateGlobalMoleculeContainerFor(IContainer rootContainer, IMoleculeBuilder moleculeBuilder, SimulationConfiguration simulationConfiguration); + IContainer CreateGlobalMoleculeContainerFor(IContainer rootContainer, IMoleculeBuilder moleculeBuilder, SimulationBuilder simulationBuilder); /// - /// Returns (and creates if not already there) the sub container for the transport process named - /// in the for the transporter + /// Returns (and creates if not already there) the sub container for the transport process named + /// + /// in the for the transporter /// - IContainer NeighborhoodMoleculeTransportContainerFor(Neighborhood neighborhood, string transportedMoleculeName, TransporterMoleculeContainer transporterMolecule, string transportName, SimulationConfiguration simulationConfiguration); + IContainer NeighborhoodMoleculeTransportContainerFor(Neighborhood neighborhood, string transportedMoleculeName, TransporterMoleculeContainer transporterMolecule, string transportName, SimulationBuilder simulationBuilder); } internal class MoleculePropertiesContainerTask : IMoleculePropertiesContainerTask @@ -52,32 +53,29 @@ public IContainer NeighborhoodMoleculeContainerFor(Neighborhood neighborhood, st return moleculeContainer; } - public IContainer CreateGlobalMoleculeContainerFor(IContainer rootContainer, IMoleculeBuilder moleculeBuilder, SimulationConfiguration simulationConfiguration) + public IContainer CreateGlobalMoleculeContainerFor(IContainer rootContainer, IMoleculeBuilder moleculeBuilder, SimulationBuilder simulationBuilder) { - var globalMoleculeContainer = addContainerUnder(rootContainer, moleculeBuilder, moleculeBuilder.Name, simulationConfiguration) + var globalMoleculeContainer = addContainerUnder(rootContainer, moleculeBuilder, moleculeBuilder.Name, simulationBuilder) .WithContainerType(ContainerType.Molecule); //Add global molecule dependent parameters if (moleculeBuilder.IsFloatingXenobiotic) { - simulationConfiguration.SpatialStructures.Select(x=>x.GlobalMoleculeDependentProperties).Each(x => - { - globalMoleculeContainer.AddChildren(addAllParametersFrom(x, simulationConfiguration)); - }); + simulationBuilder.SpatialStructures.Select(x => x.GlobalMoleculeDependentProperties).Each(x => { globalMoleculeContainer.AddChildren(addAllParametersFrom(x, simulationBuilder)); }); } //Only non local parameters from the molecule are added to the global container //Local parameters will be filled in elsewhere (by the MoleculeAmount-Mapper) - globalMoleculeContainer.AddChildren(allGlobalOrPropertyParametersFrom(moleculeBuilder, simulationConfiguration)); + globalMoleculeContainer.AddChildren(allGlobalOrPropertyParametersFrom(moleculeBuilder, simulationBuilder)); foreach (var transporterMoleculeContainer in moleculeBuilder.TransporterMoleculeContainerCollection) { - addContainerWithParametersUnder(globalMoleculeContainer, transporterMoleculeContainer, transporterMoleculeContainer.TransportName, simulationConfiguration); + addContainerWithParametersUnder(globalMoleculeContainer, transporterMoleculeContainer, transporterMoleculeContainer.TransportName, simulationBuilder); } foreach (var interactionContainer in moleculeBuilder.InteractionContainerCollection) { - addContainerWithParametersUnder(globalMoleculeContainer, interactionContainer, interactionContainer.Name, simulationConfiguration); + addContainerWithParametersUnder(globalMoleculeContainer, interactionContainer, interactionContainer.Name, simulationBuilder); } _keywordReplacer.ReplaceIn(globalMoleculeContainer, rootContainer, moleculeBuilder.Name); @@ -85,37 +83,37 @@ public IContainer CreateGlobalMoleculeContainerFor(IContainer rootContainer, IMo return globalMoleculeContainer; } - - private IContainer addContainerUnder(IContainer parentContainer, IContainer templateContainer, string newContainerName, SimulationConfiguration simulationConfiguration) + private IContainer addContainerUnder(IContainer parentContainer, IContainer templateContainer, string newContainerName, SimulationBuilder simulationBuilder) { var instanceContainer = _containerTask.CreateOrRetrieveSubContainerByName(parentContainer, newContainerName); - simulationConfiguration.AddBuilderReference(instanceContainer, templateContainer); + simulationBuilder.AddBuilderReference(instanceContainer, templateContainer); instanceContainer.Icon = templateContainer.Icon; instanceContainer.Description = templateContainer.Description; return instanceContainer; } - private IContainer addContainerWithParametersUnder(IContainer parentContainer, IContainer templateContainer, string newContainerName, SimulationConfiguration simulationConfiguration) + private IContainer addContainerWithParametersUnder(IContainer parentContainer, IContainer templateContainer, string newContainerName, SimulationBuilder simulationBuilder) { - return addContainerUnder(parentContainer, templateContainer, newContainerName, simulationConfiguration) - .WithChildren(allGlobalOrPropertyParametersFrom(templateContainer, simulationConfiguration)); - } + return addContainerUnder(parentContainer, templateContainer, newContainerName, simulationBuilder) + .WithChildren(allGlobalOrPropertyParametersFrom(templateContainer, simulationBuilder)); + } - private IEnumerable allGlobalOrPropertyParametersFrom(IContainer container, SimulationConfiguration simulationConfiguration) + private IEnumerable allGlobalOrPropertyParametersFrom(IContainer container, SimulationBuilder simulationBuilder) { - return _parameterCollectionMapper.MapGlobalOrPropertyFrom(container, simulationConfiguration); + return _parameterCollectionMapper.MapGlobalOrPropertyFrom(container, simulationBuilder); } - private IEnumerable addAllParametersFrom(IContainer container, SimulationConfiguration simulationConfiguration) + + private IEnumerable addAllParametersFrom(IContainer container, SimulationBuilder simulationBuilder) { - return _parameterCollectionMapper.MapAllFrom(container, simulationConfiguration); + return _parameterCollectionMapper.MapAllFrom(container, simulationBuilder); } - private IEnumerable allLocalParametersFrom(IContainer container, SimulationConfiguration simulationConfiguration) + private IEnumerable allLocalParametersFrom(IContainer container, SimulationBuilder simulationBuilder) { - return _parameterCollectionMapper.MapLocalFrom(container, simulationConfiguration); + return _parameterCollectionMapper.MapLocalFrom(container, simulationBuilder); } - public IContainer NeighborhoodMoleculeTransportContainerFor(Neighborhood neighborhood, string transportedMoleculeName,TransporterMoleculeContainer transporterMolecule, string transportName, SimulationConfiguration simulationConfiguration) + public IContainer NeighborhoodMoleculeTransportContainerFor(Neighborhood neighborhood, string transportedMoleculeName, TransporterMoleculeContainer transporterMolecule, string transportName, SimulationBuilder simulationBuilder) { var moleculeContainer = NeighborhoodMoleculeContainerFor(neighborhood, transportedMoleculeName); var transportContainer = moleculeContainer.EntityAt(transporterMolecule.TransportName); @@ -123,7 +121,7 @@ public IContainer NeighborhoodMoleculeTransportContainerFor(Neighborhood neighbo return transportContainer; return _containerTask.CreateOrRetrieveSubContainerByName(moleculeContainer, transporterMolecule.TransportName) - .WithChildren(allLocalParametersFrom(transporterMolecule, simulationConfiguration)); + .WithChildren(allLocalParametersFrom(transporterMolecule, simulationBuilder)); } } } \ No newline at end of file diff --git a/src/OSPSuite.Core/Domain/Services/ObserverBuilderTask.cs b/src/OSPSuite.Core/Domain/Services/ObserverBuilderTask.cs index 8b3ac655c..4948ae84f 100644 --- a/src/OSPSuite.Core/Domain/Services/ObserverBuilderTask.cs +++ b/src/OSPSuite.Core/Domain/Services/ObserverBuilderTask.cs @@ -26,7 +26,7 @@ internal class ObserverBuilderTask : IObserverBuilderTask //cache only used to speed up task private EntityDescriptorMapList _allContainerDescriptors; - private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; public ObserverBuilderTask( IObserverBuilderToObserverMapper observerMapper, @@ -40,11 +40,11 @@ public ObserverBuilderTask( public void CreateObservers(ModelConfiguration modelConfiguration) { - var (model, simulationConfiguration) = modelConfiguration; + var (model, simulationBuilder) = modelConfiguration; _allContainerDescriptors = model.Root.GetAllChildren().ToEntityDescriptorMapList(); - _simulationConfiguration = simulationConfiguration; - var observers = simulationConfiguration.Observers; - var presentMolecules = simulationConfiguration.AllPresentMolecules().ToList(); + _simulationBuilder = simulationBuilder; + var observers = simulationBuilder.Observers; + var presentMolecules = simulationBuilder.AllPresentMolecules().ToList(); try { foreach (var observerBuilder in observers.OfType()) @@ -57,7 +57,7 @@ public void CreateObservers(ModelConfiguration modelConfiguration) finally { _allContainerDescriptors = null; - _simulationConfiguration = null; + _simulationBuilder = null; } } @@ -114,7 +114,7 @@ private void createContainerObserver(IContainerObserverBuilder observerBuilder, { //should only happen for a logical container. moleculeContainer = _containerTask.CreateOrRetrieveSubContainerByName(container, moleculeBuilder.Name).WithContainerType(ContainerType.Molecule); - _simulationConfiguration.AddBuilderReference(moleculeContainer, observerBuilder); + _simulationBuilder.AddBuilderReference(moleculeContainer, observerBuilder); } var observer = addObserverInContainer(observerBuilder, moleculeContainer, moleculeBuilder.QuantityType); @@ -125,7 +125,7 @@ private void createContainerObserver(IContainerObserverBuilder observerBuilder, private IObserver addObserverInContainer(IObserverBuilder observerBuilder, IContainer observerContainer, QuantityType moleculeType) { - var observer = _observerMapper.MapFrom(observerBuilder, _simulationConfiguration); + var observer = _observerMapper.MapFrom(observerBuilder, _simulationBuilder); observer.QuantityType = QuantityType.Observer | moleculeType; observerContainer.Add(observer); return observer; diff --git a/src/OSPSuite.Core/Domain/Services/QuantityValuesUpdater.cs b/src/OSPSuite.Core/Domain/Services/QuantityValuesUpdater.cs index 511b6defb..49cc9ce4e 100644 --- a/src/OSPSuite.Core/Domain/Services/QuantityValuesUpdater.cs +++ b/src/OSPSuite.Core/Domain/Services/QuantityValuesUpdater.cs @@ -7,7 +7,7 @@ namespace OSPSuite.Core.Domain.Services { - public interface IQuantityValuesUpdater + internal interface IQuantityValuesUpdater { /// /// Update the values of all defined in the model based on the values @@ -23,7 +23,7 @@ public interface IQuantityValuesUpdater void UpdateQuantitiesValues(ModelConfiguration modelConfiguration); } - public class QuantityValuesUpdater : IQuantityValuesUpdater + internal class QuantityValuesUpdater : IQuantityValuesUpdater { private readonly IKeywordReplacerTask _keywordReplacerTask; private readonly ICloneManagerForModel _cloneManagerForModel; @@ -72,7 +72,7 @@ private void updateParameterFromIndividualValues(ModelConfiguration modelConfigu private void updateParameterValueFromParameterStartValues(ModelConfiguration modelConfiguration) { - modelConfiguration.SimulationConfiguration.ParameterStartValues + modelConfiguration.SimulationBuilder.ParameterStartValues .Each(psv => updateParameterValueFromStartValue(modelConfiguration, psv, getParameter)); } diff --git a/src/OSPSuite.Core/Domain/Services/ReactionCreator.cs b/src/OSPSuite.Core/Domain/Services/ReactionCreator.cs index b18d4b562..7d981176d 100644 --- a/src/OSPSuite.Core/Domain/Services/ReactionCreator.cs +++ b/src/OSPSuite.Core/Domain/Services/ReactionCreator.cs @@ -20,7 +20,7 @@ internal class ReactionCreator : IReactionCreator, IVisitor private readonly IParameterBuilderCollectionToParameterCollectionMapper _parameterMapper; private IModel _model; private bool _createdInstance; - private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; private IReactionBuilder _reactionBuilder; public ReactionCreator(IReactionBuilderToReactionMapper reactionMapper, IKeywordReplacerTask keywordReplacerTask, @@ -36,8 +36,7 @@ public ReactionCreator(IReactionBuilderToReactionMapper reactionMapper, IKeyword public bool CreateReaction(IReactionBuilder reactionBuilder, ModelConfiguration modelConfiguration) { _reactionBuilder = reactionBuilder; - _model = modelConfiguration.Model; - _simulationConfiguration = modelConfiguration.SimulationConfiguration; + (_model, _simulationBuilder) = modelConfiguration; try { //global container should be created before creating local reaction so that path replacement works @@ -55,7 +54,7 @@ public bool CreateReaction(IReactionBuilder reactionBuilder, ModelConfiguration { _reactionBuilder = null; _model = null; - _simulationConfiguration = null; + _simulationBuilder = null; } } @@ -66,10 +65,10 @@ private IContainer createReactionPropertiesContainer() .WithIcon(_reactionBuilder.Icon) .WithDescription(_reactionBuilder.Description); - _simulationConfiguration.AddBuilderReference(globalReactionContainer, _reactionBuilder); + _simulationBuilder.AddBuilderReference(globalReactionContainer, _reactionBuilder); //"Local"-Parameters will be filled in elsewhere (by the Reaction-Mapper) - _parameterMapper.MapGlobalOrPropertyFrom(_reactionBuilder, _simulationConfiguration).Each(globalReactionContainer.Add); + _parameterMapper.MapGlobalOrPropertyFrom(_reactionBuilder, _simulationBuilder).Each(globalReactionContainer.Add); _keywordReplacerTask.ReplaceIn(globalReactionContainer, _model.Root, _reactionBuilder.Name); return globalReactionContainer; @@ -79,7 +78,7 @@ public void Visit(IContainer container) { if (!canCreateReactionIn(container)) return; _createdInstance = true; - container.Add(_reactionMapper.MapFromLocal(_reactionBuilder, container, _simulationConfiguration)); + container.Add(_reactionMapper.MapFromLocal(_reactionBuilder, container, _simulationBuilder)); } private bool canCreateReactionIn(IContainer container) diff --git a/src/OSPSuite.Core/Domain/Services/TransportCreator.cs b/src/OSPSuite.Core/Domain/Services/TransportCreator.cs index b14ca24c0..09bee6ed7 100644 --- a/src/OSPSuite.Core/Domain/Services/TransportCreator.cs +++ b/src/OSPSuite.Core/Domain/Services/TransportCreator.cs @@ -8,13 +8,13 @@ namespace OSPSuite.Core.Domain.Services { - public interface ITransportCreator + internal interface ITransportCreator { void CreatePassiveTransport(ITransportBuilder passiveTransportBuilder, ModelConfiguration modelConfiguration); void CreateActiveTransport(ModelConfiguration modelConfiguration); } - public class TransportCreator : ITransportCreator + internal class TransportCreator : ITransportCreator { private readonly ITransportBuilderToTransportMapper _transportMapper; private readonly IKeywordReplacerTask _keywordReplacerTask; @@ -41,25 +41,20 @@ public void CreatePassiveTransport(ITransportBuilder passiveTransportBuilder, Mo public void CreateActiveTransport(ModelConfiguration modelConfiguration) { - var (model, simulationConfiguration) = modelConfiguration; + var (model, simulationBuilder) = modelConfiguration; var allNeighborhoods = model.Neighborhoods.GetChildren().ToList(); - //TODO can we have a transport define in one grabbing a molecule from another module? - foreach (var module in simulationConfiguration.ModuleConfigurations.Select(x=>x.Module).Where(x=>x.Molecules!=null)) + foreach (var molecule in simulationBuilder.AllFloatingMolecules()) { - var molecules = module.Molecules; - foreach (var molecule in molecules.AllFloating()) + foreach (var transporterMolecule in molecule.TransporterMoleculeContainerCollection) { - foreach (var transporterMolecule in molecule.TransporterMoleculeContainerCollection) + var transporter = simulationBuilder.MoleculeByName(transporterMolecule.Name); + // transporter not available in molecules (can happen when swapping building block) + if (transporter == null) + continue; + + foreach (var activeTransport in transporterMolecule.ActiveTransportRealizations) { - var transporter = molecules[transporterMolecule.Name]; - // transporter not available in molecules (can happen when swapping building block) - if (transporter == null) - continue; - - foreach (var activeTransport in transporterMolecule.ActiveTransportRealizations) - { - addActiveTransportToModel(activeTransport, allNeighborhoods, molecule, transporterMolecule, modelConfiguration); - } + addActiveTransportToModel(activeTransport, allNeighborhoods, molecule, transporterMolecule, modelConfiguration); } } } @@ -68,7 +63,7 @@ public void CreateActiveTransport(ModelConfiguration modelConfiguration) private void addPassiveTransportToModel(ITransportBuilder passiveTransportBuilder, IEnumerable allNeighborhoods, IMoleculeBuilder molecule, ModelConfiguration modelConfiguration) { - var (model, simulationConfiguration) = modelConfiguration; + var (model, simulationBuilder) = modelConfiguration; // first check if the molecule should be transported if (!passiveTransportBuilder.TransportsMolecule(molecule.Name)) return; @@ -77,7 +72,7 @@ private void addPassiveTransportToModel(ITransportBuilder passiveTransportBuilde foreach (var neighborhood in neighborhoods) { - var passiveTransport = mapFrom(passiveTransportBuilder, neighborhood, molecule.Name, simulationConfiguration); + var passiveTransport = mapFrom(passiveTransportBuilder, neighborhood, molecule.Name, simulationBuilder); addPassiveTransportToNeighborhood(neighborhood, molecule.Name, passiveTransport); _keywordReplacerTask.ReplaceIn(passiveTransport, model.Root, molecule.Name, neighborhood); } @@ -151,17 +146,17 @@ private IContainer addPassiveTransportToNeighborhood(Neighborhood neighborhood, } private IContainer addActiveTransportToNeighborhood(Neighborhood neighborhood, ITransport transport, - TransporterMoleculeContainer transporterMolecule, string transportedMoleculeName, SimulationConfiguration simulationConfiguration) + TransporterMoleculeContainer transporterMolecule, string transportedMoleculeName, SimulationBuilder simulationBuilder) { return _moleculePropertiesContainerTask.NeighborhoodMoleculeTransportContainerFor(neighborhood, transportedMoleculeName, transporterMolecule, - transport.Name, simulationConfiguration) + transport.Name, simulationBuilder) .WithChild(transport); } private ITransport mapFrom(ITransportBuilder transportBuilder, Neighborhood neighborhood, string moleculeName, - SimulationConfiguration simulationConfiguration) + SimulationBuilder simulationBuilder) { - var transport = _transportMapper.MapFrom(transportBuilder, simulationConfiguration); + var transport = _transportMapper.MapFrom(transportBuilder, simulationBuilder); transport.SourceAmount = neighborhood.GetNeighborSatisfying(transportBuilder.SourceCriteria) .GetSingleChildByName(moleculeName); transport.TargetAmount = neighborhood.GetNeighborSatisfying(transportBuilder.TargetCriteria) diff --git a/src/OSPSuite.Core/Services/CircularReferenceChecker.cs b/src/OSPSuite.Core/Services/CircularReferenceChecker.cs index 688effef1..2236281ac 100644 --- a/src/OSPSuite.Core/Services/CircularReferenceChecker.cs +++ b/src/OSPSuite.Core/Services/CircularReferenceChecker.cs @@ -10,7 +10,7 @@ namespace OSPSuite.Core.Services { - public interface ICircularReferenceChecker + internal interface ICircularReferenceChecker { /// /// Returns true if the usage of in the formula of @@ -65,10 +65,10 @@ public ValidationResult CheckCircularReferencesIn(ModelConfiguration modelConfig try { - var (model, simulationConfiguration) = modelConfiguration; + var (model, simulationBuilder) = modelConfiguration; var allUsingFormulas = model.Root.GetAllChildren(); allUsingFormulas.Each(buildEntityReferenceCache); - allUsingFormulas.Each(x => checkCircularReferencesIn(x, simulationConfiguration, validationResult)); + allUsingFormulas.Each(x => checkCircularReferencesIn(x, simulationBuilder, validationResult)); return validationResult; } finally @@ -100,14 +100,14 @@ private void buildEntityReferenceCache(IUsingFormula usingFormula) } } - private void checkCircularReferencesIn(IUsingFormula usingFormula, SimulationConfiguration simulationConfiguration, ValidationResult validationResult) + private void checkCircularReferencesIn(IUsingFormula usingFormula, SimulationBuilder simulationBuilder, ValidationResult validationResult) { var references = _entityReferenceCache[usingFormula]; if (!references.Contains(usingFormula)) return; var entityAbsolutePath = _objectPathFactory.CreateAbsoluteObjectPath(usingFormula).ToPathString(); - var builder = simulationConfiguration.BuilderFor(usingFormula); + var builder = simulationBuilder.BuilderFor(usingFormula); var objectWithError = builder ?? usingFormula; var entityType = _objectTypeResolver.TypeFor(usingFormula); var allReferencesName = references.Distinct().AllNames(); diff --git a/src/OSPSuite.Core/Services/SimulationConfigurationDisposer.cs b/src/OSPSuite.Core/Services/SimulationConfigurationDisposer.cs deleted file mode 100644 index c797400f3..000000000 --- a/src/OSPSuite.Core/Services/SimulationConfigurationDisposer.cs +++ /dev/null @@ -1,41 +0,0 @@ -using System; -using OSPSuite.Core.Domain.Builder; - -namespace OSPSuite.Core.Services -{ - public class SimulationConfigurationDisposer : IDisposable - { - private readonly SimulationConfiguration _simulationConfiguration; - - public SimulationConfigurationDisposer(SimulationConfiguration simulationConfiguration) - { - _simulationConfiguration = simulationConfiguration; - _simulationConfiguration.Freeze(); - } - - protected virtual void Cleanup() - { - _simulationConfiguration.ClearCache(); - } - - #region Disposable properties - - private bool _disposed; - - public void Dispose() - { - if (_disposed) return; - - Cleanup(); - GC.SuppressFinalize(this); - _disposed = true; - } - - ~SimulationConfigurationDisposer() - { - Cleanup(); - } - - #endregion - } -} \ No newline at end of file diff --git a/src/OSPSuite.R/Domain/Simulation.cs b/src/OSPSuite.R/Domain/Simulation.cs index 57a5aa385..cd02ec280 100644 --- a/src/OSPSuite.R/Domain/Simulation.cs +++ b/src/OSPSuite.R/Domain/Simulation.cs @@ -116,7 +116,7 @@ public SimulationConfiguration Configuration set => CoreSimulation.Configuration = value; } - public IReadOnlyCollection Reactions => CoreSimulation.Reactions; + public IReadOnlyCollection Reactions => CoreSimulation.Reactions; public IReadOnlyList CompoundNames => CoreSimulation.CompoundNames; diff --git a/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs b/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs index 5195ff689..59070fb14 100644 --- a/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs +++ b/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs @@ -15,20 +15,20 @@ namespace OSPSuite.Core { - public abstract class concern_for_ModelConstructor : ContextForIntegration + internal abstract class concern_for_ModelConstructor : ContextForIntegration { protected SimulationConfiguration _simulationConfiguration; protected CreationResult _result; protected IModel _model; protected string _modelName = "MyModel"; + protected SimulationBuilder _simulationBuilder; - public override void GlobalContext() + protected override void Context() { - base.GlobalContext(); + base.Context(); + //we create the simulation in context as some tests are modifying it _simulationConfiguration = IoC.Resolve().CreateSimulationConfiguration(); - //Freeze in constructor in case access is also required to properties for setup - _simulationConfiguration.Freeze(); } protected override void Because() @@ -36,12 +36,12 @@ protected override void Because() sut = IoC.Resolve(); _result = sut.CreateModelFrom(_simulationConfiguration, _modelName); //Freeze in the test so that we can access the properties. This needs to be done AFTER the model creation - _simulationConfiguration.Freeze(); _model = _result.Model; + _simulationBuilder = _result.SimulationBuilder; } } - public class When_running_the_case_study : concern_for_ModelConstructor + internal class When_running_the_case_study : concern_for_ModelConstructor { [Observation] public void should_return_a_successful_validation() @@ -388,7 +388,7 @@ public void each_parameter_using_formula_defined_in_the_simulation_should_have_a var errorList = new List(); foreach (var entity in _model.Root.GetAllChildren()) { - var builder = _simulationConfiguration.BuilderFor(entity); + var builder = _simulationBuilder.BuilderFor(entity); if (builder != null) continue; if (entity.IsNamed(Constants.NEIGHBORHOODS)) continue; errorList.Add($"No builder found for {entity.Name}"); @@ -505,13 +505,16 @@ internal static IMoleculeAmount ModelOrganCompartmentMolecule(this IModel model, } } - public class When_a_molecule_start_value_is_defined_for_logical_container : concern_for_ModelConstructor + internal class When_a_molecule_start_value_is_defined_for_logical_container : concern_for_ModelConstructor { protected override void Context() { base.Context(); - var moleculeStartValue = _simulationConfiguration.MoleculeStartValues.First(); - var physicalContainer = _simulationConfiguration.SpatialStructures.SelectMany(x => x.TopContainers) + //we use a sim builder here to modify the configuration on the fly + var simulationBuilder = new SimulationBuilder(_simulationConfiguration); + + var moleculeStartValue = simulationBuilder.MoleculeStartValues.First(); + var physicalContainer = simulationBuilder.SpatialStructures.SelectMany(x => x.TopContainers) .Select(x => moleculeStartValue.ContainerPath.TryResolve(x)).First(x => x != null); physicalContainer.Mode = ContainerMode.Logical; @@ -524,12 +527,14 @@ public void should_identify_an_issue_with_start_values_being_defined_for_logical } } - public class When_running_the_case_study_with_a_missing_parameter : concern_for_ModelConstructor + internal class When_running_the_case_study_with_a_missing_parameter : concern_for_ModelConstructor { protected override void Context() { base.Context(); - var molecule = _simulationConfiguration.MoleculeByName("A"); + //we use a sim builder here to modify the configuration on the fly + var simulationBuilder = new SimulationBuilder(_simulationConfiguration); + var molecule = simulationBuilder.MoleculeByName("A"); var paraToRemove = molecule.Parameters.SingleOrDefault(para => para.Name == "logMA"); molecule.RemoveParameter(paraToRemove); } @@ -542,7 +547,7 @@ public void should_return_an_invalid_validation() } } - public class When_naming_the_model_like_a_distributed_parameter_sub_parameter : concern_for_ModelConstructor + internal class When_naming_the_model_like_a_distributed_parameter_sub_parameter : concern_for_ModelConstructor { protected override void Context() { @@ -557,7 +562,7 @@ public void should_be_able_to_create_the_model() } } - public class When_naming_the_model_like_the_neighborhood_container : concern_for_ModelConstructor + internal class When_naming_the_model_like_the_neighborhood_container : concern_for_ModelConstructor { protected override void Context() { @@ -572,7 +577,7 @@ public void should_not_be_able_to_create_the_model() } } - public class When_naming_the_model_like_the_organism_container : concern_for_ModelConstructor + internal class When_naming_the_model_like_the_organism_container : concern_for_ModelConstructor { protected override void Context() { diff --git a/tests/OSPSuite.Core.IntegrationTests/ModuleIntegrationTests.cs b/tests/OSPSuite.Core.IntegrationTests/ModuleIntegrationTests.cs index 619a2f07d..c5c98a9e4 100644 --- a/tests/OSPSuite.Core.IntegrationTests/ModuleIntegrationTests.cs +++ b/tests/OSPSuite.Core.IntegrationTests/ModuleIntegrationTests.cs @@ -10,33 +10,31 @@ namespace OSPSuite.Core { - public abstract class concern_for_ModuleIntegration : ContextForIntegration + internal abstract class concern_for_ModuleIntegration : ContextForIntegration { protected SimulationConfiguration _simulationConfiguration; protected CreationResult _result; protected IModel _model; protected string _modelName = "MyModel"; + protected SimulationBuilder _simulationBuilder; public override void GlobalContext() { base.GlobalContext(); _simulationConfiguration = IoC.Resolve().CreateSimulationConfiguration(); - //Freeze in constructor in case access is also required to properties for setup - _simulationConfiguration.Freeze(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); } protected override void Because() { sut = IoC.Resolve(); _result = sut.CreateModelFrom(_simulationConfiguration, _modelName); - //Freeze in the test so that we can access the properties. This needs to be done AFTER the model creation - _simulationConfiguration.Freeze(); _model = _result.Model; } } - public class When_running_the_case_study_for_module_integration : concern_for_ModuleIntegration + internal class When_running_the_case_study_for_module_integration : concern_for_ModuleIntegration { [Observation] public void should_return_a_successful_validation() diff --git a/tests/OSPSuite.Core.IntegrationTests/Serializers/BuildingBlockXmlSerializerSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/Serializers/BuildingBlockXmlSerializerSpecs.cs index c0ca747dd..4369e0b25 100644 --- a/tests/OSPSuite.Core.IntegrationTests/Serializers/BuildingBlockXmlSerializerSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/Serializers/BuildingBlockXmlSerializerSpecs.cs @@ -8,7 +8,7 @@ namespace OSPSuite.Core.Serializers { - public class BuildingBlockWithFormulaCacheXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class BuildingBlockWithFormulaCacheXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestSimpleBB() @@ -61,7 +61,7 @@ public void TestComplexObserverBB() } } - public class MoleculeBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class MoleculeBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexMoleculeBB() @@ -72,7 +72,7 @@ public void TestComplexMoleculeBB() } } - public class PassiveTransportBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class PassiveTransportBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexPassiveTransportBB() @@ -83,7 +83,7 @@ public void TestComplexPassiveTransportBB() } } - public class ReactionBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class ReactionBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexReactionBB() @@ -94,7 +94,7 @@ public void TestComplexReactionBB() } } - public class EventGroupBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class EventGroupBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexEventGroupBB() @@ -112,18 +112,18 @@ public void TestComplexEventGroupBB() } } - public class SpatialStructureXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class SpatialStructureXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexSpatialStructure() { - var x1 = _simulationConfiguration.SpatialStructures[0]; + var x1 = _simulationBuilder.SpatialStructures[0]; var x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualSpatialStructure(x2, x1); } } - public class MoleculeStartValuesBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class MoleculeStartValuesBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexMoleculeStartValuesBuildingBlock() @@ -134,7 +134,7 @@ public void TestComplexMoleculeStartValuesBuildingBlock() } } - public class ParameterStartValuesBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class ParameterStartValuesBuildingBlockXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexParameterStartValuesBuildingBlock() @@ -145,7 +145,7 @@ public void TestComplexParameterStartValuesBuildingBlock() } } - public class SimulationConfigurationXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class SimulationConfigurationXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestComplexBuildConfiguration() diff --git a/tests/OSPSuite.Core.IntegrationTests/Serializers/ModelXmlSerializerSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/Serializers/ModelXmlSerializerSpecs.cs index 5ac4d24a5..59fc7bc0b 100644 --- a/tests/OSPSuite.Core.IntegrationTests/Serializers/ModelXmlSerializerSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/Serializers/ModelXmlSerializerSpecs.cs @@ -5,7 +5,7 @@ namespace OSPSuite.Core.Serializers { - public class ModelXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class ModelXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { [Test] public void TestSimpleModelContainer() diff --git a/tests/OSPSuite.Core.IntegrationTests/Serializers/ModellingXmlSerializerBaseSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/Serializers/ModellingXmlSerializerBaseSpecs.cs index 73def13db..2488d262c 100644 --- a/tests/OSPSuite.Core.IntegrationTests/Serializers/ModellingXmlSerializerBaseSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/Serializers/ModellingXmlSerializerBaseSpecs.cs @@ -37,7 +37,7 @@ public override void GlobalContext() } } - public abstract class ModellingXmlSerializerWithModelBaseSpecs : ModellingXmlSerializerBaseSpecs + internal abstract class ModellingXmlSerializerWithModelBaseSpecs : ModellingXmlSerializerBaseSpecs { protected SimulationConfiguration _simulationConfiguration; protected IObjectPathFactory _objectPathFactory; @@ -47,6 +47,7 @@ public abstract class ModellingXmlSerializerWithModelBaseSpecs : ModellingXmlSer protected IModelCoreSimulation _simulation; protected IModelConstructor _modelConstructor; protected Module _module; + protected SimulationBuilder _simulationBuilder; public override void GlobalContext() { @@ -59,6 +60,7 @@ protected virtual void InitializeSimulation() _objectPathFactory = IoC.Resolve(); _moleculeStartValuesCreator = IoC.Resolve(); _simulationConfiguration = IoC.Resolve().CreateSimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _module = _simulationConfiguration.ModuleConfigurations[0].Module; _modelConstructor = IoC.Resolve(); _result = _modelConstructor.CreateModelFrom(_simulationConfiguration, "MyModel"); diff --git a/tests/OSPSuite.Core.IntegrationTests/Serializers/SimulationXmlSerializerSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/Serializers/SimulationXmlSerializerSpecs.cs index 13cb52982..275a4e0f2 100644 --- a/tests/OSPSuite.Core.IntegrationTests/Serializers/SimulationXmlSerializerSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/Serializers/SimulationXmlSerializerSpecs.cs @@ -1,14 +1,11 @@ using NUnit.Framework; -using OSPSuite.Core.Domain; using OSPSuite.Core.Domain.Services; using OSPSuite.Core.Helpers; -using OSPSuite.Helpers; namespace OSPSuite.Core.Serializers { - public class SimulationXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs + internal class SimulationXmlSerializerSpecs : ModellingXmlSerializerWithModelBaseSpecs { - [Test] public void TestComplexSimulation() { diff --git a/tests/OSPSuite.Core.IntegrationTests/SimulationPersistorSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/SimulationPersistorSpecs.cs index 31cc88f41..d41476c34 100644 --- a/tests/OSPSuite.Core.IntegrationTests/SimulationPersistorSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/SimulationPersistorSpecs.cs @@ -16,7 +16,7 @@ namespace OSPSuite.Core { - public abstract class concern_for_SimulationPersistor : ModellingXmlSerializerWithModelBaseSpecs + internal abstract class concern_for_SimulationPersistor : ModellingXmlSerializerWithModelBaseSpecs { protected ISimulationPersistor _simulationPersistor; protected string _filePath; @@ -37,7 +37,7 @@ public override void Cleanup() } } - public class When_deserializing_a_valid_simulation_file_containing_some_licenses : concern_for_SimulationPersistor + internal class When_deserializing_a_valid_simulation_file_containing_some_licenses : concern_for_SimulationPersistor { [Observation] public void should_return_a_simulation_transfer_containing_a_valid_simulation() @@ -58,12 +58,12 @@ public void should_return_a_simulation_transfer_containing_a_valid_simulation() } } - public class When_deserializing_a_pkml_file_that_does_not_contain_a_simulation : concern_for_SimulationPersistor + internal class When_deserializing_a_pkml_file_that_does_not_contain_a_simulation : concern_for_SimulationPersistor { [Observation] public void should_throw_an_exception() { - _pkmlPersistor.SaveToPKML(_simulation.Configuration.SpatialStructures[0], _filePath); + _pkmlPersistor.SaveToPKML(_simulationBuilder.SpatialStructures[0], _filePath); File.Exists(_filePath).ShouldBeTrue(); var deserializationObjectBaseRepository = IoC.Resolve(); @@ -73,7 +73,7 @@ public void should_throw_an_exception() } } - public class When_deserializing_a_simulation_transfer_containing_observed_data_and_mapping : concern_for_SimulationPersistor + internal class When_deserializing_a_simulation_transfer_containing_observed_data_and_mapping : concern_for_SimulationPersistor { private SimulationTransfer _simulationTransfer; private DataRepository _obsData; diff --git a/tests/OSPSuite.Core.IntegrationTests/SpatialStructureSpecs.cs b/tests/OSPSuite.Core.IntegrationTests/SpatialStructureSpecs.cs index 1ae13a73f..02e7a0ac7 100644 --- a/tests/OSPSuite.Core.IntegrationTests/SpatialStructureSpecs.cs +++ b/tests/OSPSuite.Core.IntegrationTests/SpatialStructureSpecs.cs @@ -9,14 +9,16 @@ namespace OSPSuite.Core { - public abstract class concern_for_SpatialStructure : ContextForIntegration + internal abstract class concern_for_SpatialStructure : ContextForIntegration { protected SimulationConfiguration _simulationConfiguration; + protected SimulationBuilder _simulationBuilder; public override void GlobalContext() { base.GlobalContext(); _simulationConfiguration = IoC.Resolve().CreateSimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); } protected override void Context() @@ -25,7 +27,7 @@ protected override void Context() } } - public class When_told_to_update_properties_from_a_source_spatial_structure_with_clone_manager_for_building_blocks : concern_for_SpatialStructure + internal class When_told_to_update_properties_from_a_source_spatial_structure_with_clone_manager_for_building_blocks : concern_for_SpatialStructure { private ISpatialStructure _sourceSpatialStructure; private ICloneManagerForBuildingBlock _cloneManager; @@ -34,7 +36,7 @@ public class When_told_to_update_properties_from_a_source_spatial_structure_with protected override void Context() { base.Context(); - _sourceSpatialStructure = _simulationConfiguration.SpatialStructures[0]; + _sourceSpatialStructure = _simulationBuilder.SpatialStructures[0]; _sourceSpatialStructure.Version = _buildingBlockVersion; _cloneManager = IoC.Resolve(); } diff --git a/tests/OSPSuite.Core.Tests/Domain/ModelCoreSimulationExtensionsSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ModelCoreSimulationExtensionsSpecs.cs index 8ff77faeb..81130273b 100644 --- a/tests/OSPSuite.Core.Tests/Domain/ModelCoreSimulationExtensionsSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/ModelCoreSimulationExtensionsSpecs.cs @@ -17,7 +17,7 @@ protected override void Context() { Root = new Container { new EventGroup() } }, - Configuration = new SimulationConfigurationForSpecs() + Configuration = new SimulationConfiguration() }; var reactionBuildingBlock = new ReactionBuildingBlock(); var reactionAtoB = new ReactionBuilder(); @@ -34,7 +34,7 @@ protected override void Context() reactionBuildingBlock.Add(reactionBtoA); var module = new Module {Reactions = reactionBuildingBlock}; - var moduleConfiguration = new ModuleConfiguration(module); + var moduleConfiguration = new ModuleConfiguration(module, null, null); _simulation.Configuration.AddModuleConfiguration(moduleConfiguration); } diff --git a/tests/OSPSuite.Core.Tests/Domain/ModelValidatorSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ModelValidatorSpecs.cs index a514f7bde..9efbc6779 100644 --- a/tests/OSPSuite.Core.Tests/Domain/ModelValidatorSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/ModelValidatorSpecs.cs @@ -24,7 +24,7 @@ internal abstract class concern_for_ModelValidator : ContextSpecification(); _model = new Model(); - _modelConfiguration = new ModelConfiguration(_model, _simulationConfiguration); + _modelConfiguration = new ModelConfiguration(_model, _simulationConfiguration, new SimulationBuilder(_simulationConfiguration)); } } diff --git a/tests/OSPSuite.Core.Tests/Domain/ModuleConfigurationSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ModuleConfigurationSpecs.cs new file mode 100644 index 000000000..3d9bdf32f --- /dev/null +++ b/tests/OSPSuite.Core.Tests/Domain/ModuleConfigurationSpecs.cs @@ -0,0 +1,63 @@ +using OSPSuite.BDDHelper; +using OSPSuite.BDDHelper.Extensions; +using OSPSuite.Core.Domain.Builder; + +namespace OSPSuite.Core.Domain +{ + public abstract class concern_for_ModuleConfiguration : ContextSpecification + { + protected Module _module; + protected MoleculeStartValuesBuildingBlock _moleculeStartValuesBuildingBlock1; + protected MoleculeStartValuesBuildingBlock _moleculeStartValuesBuildingBlock2; + protected ParameterStartValuesBuildingBlock _parameterStartValuesBuildingBlock; + + protected override void Context() + { + _module = new Module() + { + PassiveTransports = new PassiveTransportBuildingBlock(), + SpatialStructure = new SpatialStructure(), + Observers = new ObserverBuildingBlock(), + EventGroups = null, + Reactions = new ReactionBuildingBlock(), + Molecules = new MoleculeBuildingBlock() + }; + + _moleculeStartValuesBuildingBlock1 = new MoleculeStartValuesBuildingBlock(); + _moleculeStartValuesBuildingBlock2 = new MoleculeStartValuesBuildingBlock(); + _module.AddMoleculeStartValueBlock(_moleculeStartValuesBuildingBlock1); + _module.AddMoleculeStartValueBlock(_moleculeStartValuesBuildingBlock2); + _parameterStartValuesBuildingBlock = new ParameterStartValuesBuildingBlock(); + _module.AddParameterStartValueBlock(_parameterStartValuesBuildingBlock); + + sut =new ModuleConfiguration(_module); + } + } + + public class When_creating_new_module_configuration_from_a_module : concern_for_ModuleConfiguration + { + [Observation] + public void should_return_the_fist_molecule_start_value_and_parameter_start_value_if_one_is_defined() + { + sut.SelectedMoleculeStartValues.ShouldBeEqualTo(_moleculeStartValuesBuildingBlock1); + sut.SelectedParameterStartValues.ShouldBeEqualTo(_parameterStartValuesBuildingBlock); + } + } + + + public class When_creating_new_module_configuration_from_a_module_with_predefined_start_values : concern_for_ModuleConfiguration + { + protected override void Context() + { + base.Context(); + sut = new ModuleConfiguration(_module, _moleculeStartValuesBuildingBlock2, _parameterStartValuesBuildingBlock); + } + + [Observation] + public void should_return_the_expected_molecule_and_parameter_start_values() + { + sut.SelectedMoleculeStartValues.ShouldBeEqualTo(_moleculeStartValuesBuildingBlock2); + sut.SelectedParameterStartValues.ShouldBeEqualTo(_parameterStartValuesBuildingBlock); + } + } +} \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Domain/ModuleSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ModuleSpecs.cs index 3ff8ac0e4..49c3dc669 100644 --- a/tests/OSPSuite.Core.Tests/Domain/ModuleSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/ModuleSpecs.cs @@ -133,7 +133,7 @@ public void should_have_created_a_clone_with_the_same_properties() } } - class When_adding_a_building_block_to_a_module : concern_for_Module + public class When_adding_a_building_block_to_a_module : concern_for_Module { protected IBuildingBlock _buildingBlock; @@ -157,7 +157,7 @@ public void should_add_a_reaction() } } - class When_adding_a_not_supported_building_block_to_a_module : concern_for_Module + public class When_adding_a_not_supported_building_block_to_a_module : concern_for_Module { protected IBuildingBlock _buildingBlock; @@ -175,7 +175,7 @@ public void nothing_should_be_added() } } - class When_adding_a_null_building_block_to_a_module : concern_for_Module + public class When_adding_a_null_building_block_to_a_module : concern_for_Module { protected IBuildingBlock _buildingBlock; diff --git a/tests/OSPSuite.Core.Tests/Domain/MoleculePropertiesContainerTaskSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/MoleculePropertiesContainerTaskSpecs.cs index 0818bb37d..f7f1ba6e5 100644 --- a/tests/OSPSuite.Core.Tests/Domain/MoleculePropertiesContainerTaskSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/MoleculePropertiesContainerTaskSpecs.cs @@ -16,11 +16,13 @@ internal abstract class concern_for_MoleculePropertiesContainerTask : ContextSpe protected IContainer _rootContainer; protected IKeywordReplacerTask _keywordReplacer; protected SimulationConfiguration _simulationConfiguration; + protected SimulationBuilder _simulationBuilder; protected override void Context() { _containerTask = A.Fake(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _rootContainer = new Container(); _parameterCollectionMapper = A.Fake(); _keywordReplacer = A.Fake(); @@ -70,7 +72,7 @@ protected override void Context() _globalMoleculeDependentProperties = new Container(); - A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_moleculeBuilder, _simulationConfiguration)) + A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_moleculeBuilder, _simulationBuilder)) .Returns(new[] {_para1, _para2}); _globalMoleculeDepParam1 = new Parameter().WithName("GMDP1"); @@ -79,7 +81,7 @@ protected override void Context() _globalMoleculeDependentProperties.Add(_globalMoleculeDepParam1); _globalMoleculeDependentProperties.Add(_globalMoleculeDepParam2); - A.CallTo(() => _parameterCollectionMapper.MapAllFrom(_globalMoleculeDependentProperties, _simulationConfiguration)) + A.CallTo(() => _parameterCollectionMapper.MapAllFrom(_globalMoleculeDependentProperties, _simulationBuilder)) .Returns(new[] {_globalMoleculeDepParam1, _globalMoleculeDepParam2}); var spatialStructure = A.Fake(); @@ -93,7 +95,7 @@ protected override void Context() protected override void Because() { - _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationConfiguration); + _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationBuilder); } [Observation] @@ -145,7 +147,7 @@ protected override void Context() protected override void Because() { - _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationConfiguration); + _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationBuilder); } [Observation] @@ -180,7 +182,7 @@ protected override void Context() _para1 = new Parameter().WithName("Para1"); A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_rootContainer, _moleculeBuilder.Name)).Returns(_moleculeContainer); - A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_moleculeBuilder, _simulationConfiguration)) + A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_moleculeBuilder, _simulationBuilder)) .Returns(new[] {_para1}); _globalMoleculeDependentProperties = new Container(); @@ -188,7 +190,7 @@ protected override void Context() _globalMoleculeDepParam1 = new Parameter().WithName("GMDP1"); _globalMoleculeDependentProperties.Add(_globalMoleculeDepParam1); - A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_globalMoleculeDependentProperties, _simulationConfiguration)) + A.CallTo(() => _parameterCollectionMapper.MapGlobalOrPropertyFrom(_globalMoleculeDependentProperties, _simulationBuilder)) .Returns(new[] {_globalMoleculeDepParam1}); var spatialStructure = A.Fake(); @@ -202,7 +204,7 @@ protected override void Context() protected override void Because() { - _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationConfiguration); + _result = sut.CreateGlobalMoleculeContainerFor(_rootContainer, _moleculeBuilder, _simulationBuilder); } [Observation] diff --git a/tests/OSPSuite.Core.Tests/Domain/ProcessRateParameterCreatorSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ProcessRateParameterCreatorSpecs.cs index 355fc8fa6..bb7c549eb 100644 --- a/tests/OSPSuite.Core.Tests/Domain/ProcessRateParameterCreatorSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/ProcessRateParameterCreatorSpecs.cs @@ -8,7 +8,7 @@ namespace OSPSuite.Core.Domain { - public abstract class concern_for_ProcessRateParameterCreatorSpecs : ContextSpecification + internal abstract class concern_for_ProcessRateParameterCreatorSpecs : ContextSpecification { protected IObjectBaseFactory _objectBaseFactory; protected IFormulaBuilderToFormulaMapper _formulaMapper; @@ -20,7 +20,7 @@ protected override void Context() sut = new ProcessRateParameterCreator(_objectBaseFactory,_formulaMapper); } } - public class When_creating_a_parameter_rate_for_a_process_builder : concern_for_ProcessRateParameterCreatorSpecs + internal class When_creating_a_parameter_rate_for_a_process_builder : concern_for_ProcessRateParameterCreatorSpecs { private IFormula _kinetic; private IParameter _processRateParameter; @@ -30,25 +30,27 @@ public class When_creating_a_parameter_rate_for_a_process_builder : concern_for_ private FormulaUsablePath _formulaUsablePathA; private FormulaUsablePath _formulaUsablePathFU; private FormulaUsablePath _formulaUsablePathBW; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _processBuilder = new ReactionBuilder(); _processBuilder.CreateProcessRateParameter = true; _kinetic = new ExplicitFormula("(A+B)*fu/BW"); - _formulaUsablePathA = new FormulaUsablePath(new[] {ObjectPath.PARENT_CONTAINER, "A"}).WithAlias("A"); + _formulaUsablePathA = new FormulaUsablePath(ObjectPath.PARENT_CONTAINER, "A").WithAlias("A"); _kinetic.AddObjectPath(_formulaUsablePathA); - _formulaUsablePathB = new FormulaUsablePath(new[] { "B" }).WithAlias("B"); + _formulaUsablePathB = new FormulaUsablePath("B").WithAlias("B"); _kinetic.AddObjectPath(_formulaUsablePathB); - _formulaUsablePathFU = new FormulaUsablePath(new[] {ObjectPathKeywords.MOLECULE, "fu"}).WithAlias("fu"); + _formulaUsablePathFU = new FormulaUsablePath(ObjectPathKeywords.MOLECULE, "fu").WithAlias("fu"); _kinetic.AddObjectPath(_formulaUsablePathFU); - _formulaUsablePathBW = new FormulaUsablePath(new[] { "Organism", "BW" }).WithAlias("BW"); + _formulaUsablePathBW = new FormulaUsablePath("Organism", "BW").WithAlias("BW"); _kinetic.AddObjectPath(_formulaUsablePathBW); _processBuilder.CreateProcessRateParameter = true; _processBuilder.ProcessRateParameterPersistable = true; - A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _simulationConfiguration)).Returns(_kinetic); + A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _simulationBuilder)).Returns(_kinetic); _processBuilder.Name = "Reaction"; _processBuilder.Formula = _kinetic; _processRateParameter = new Parameter(); @@ -58,7 +60,7 @@ protected override void Context() protected override void Because() { - _processRateParameter = sut.CreateProcessRateParameterFor(_processBuilder, _simulationConfiguration); + _processRateParameter = sut.CreateProcessRateParameterFor(_processBuilder, _simulationBuilder); } [Observation] @@ -80,14 +82,14 @@ public void created_parameter_should_be_default() } [Observation] - public void should_update_reative_paths() + public void should_update_relative_paths() { _formulaUsablePathA.ShouldOnlyContainInOrder(ObjectPath.PARENT_CONTAINER,ObjectPath.PARENT_CONTAINER,"A"); _formulaUsablePathB.ShouldOnlyContainInOrder(ObjectPath.PARENT_CONTAINER, "B"); } [Observation] - public void should_leave_absolutPaths_unchanged() + public void should_leave_absolute_paths_unchanged() { _formulaUsablePathBW.ShouldOnlyContainInOrder("Organism", "BW"); _formulaUsablePathFU.ShouldOnlyContainInOrder(ObjectPathKeywords.MOLECULE, "fu"); diff --git a/tests/OSPSuite.Core.Tests/Domain/ReactionCreatorSpecs.cs b/tests/OSPSuite.Core.Tests/Domain/ReactionCreatorSpecs.cs index 6b17ad391..6c706327c 100644 --- a/tests/OSPSuite.Core.Tests/Domain/ReactionCreatorSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Domain/ReactionCreatorSpecs.cs @@ -5,7 +5,6 @@ using OSPSuite.Core.Domain.Descriptors; using OSPSuite.Core.Domain.Mappers; using OSPSuite.Core.Domain.Services; -using OSPSuite.Helpers; namespace OSPSuite.Core.Domain { @@ -25,6 +24,7 @@ internal abstract class concern_for_ReactionCreator : ContextSpecification(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _reactionBuilder = A.Fake(); _reactionBuilder.ContainerCriteria = new DescriptorCriteria(); _reactionBuilder.Description = "A great description"; @@ -55,13 +56,13 @@ protected override void Context() _globalContainer = new Container(); _reaction = A.Fake().WithName(_reactionBuilder.Name); - A.CallTo(() => _reactionMapper.MapFromLocal(A._, A._, _simulationConfiguration)).Returns(_reaction); + A.CallTo(() => _reactionMapper.MapFromLocal(A._, A._, _simulationBuilder)).Returns(_reaction); A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_rootContainer, _reactionBuilder.Name)).Returns(_globalContainer); } protected override void Because() { - _result = sut.CreateReaction(_reactionBuilder, new ModelConfiguration(_model, _simulationConfiguration)); + _result = sut.CreateReaction(_reactionBuilder, new ModelConfiguration(_model, _simulationConfiguration, _simulationBuilder)); } } diff --git a/tests/OSPSuite.Core.Tests/Mappers/ContainerBuilderToContainerMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/ContainerBuilderToContainerMapperSpecs.cs index 64db1cf1c..04e8ca73a 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/ContainerBuilderToContainerMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/ContainerBuilderToContainerMapperSpecs.cs @@ -9,7 +9,7 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_container_builder_to_container : ContextSpecification + internal abstract class concern_for_container_builder_to_container : ContextSpecification { protected ICloneManagerForModel _cloneManagerForModel; @@ -21,7 +21,7 @@ protected override void Context() } - public class When_mapping_a_container_from_a_container_builder : concern_for_container_builder_to_container + internal class When_mapping_a_container_from_a_container_builder : concern_for_container_builder_to_container { private IContainer _containerBuilder; private IContainer _clonedContainer; @@ -29,6 +29,7 @@ public class When_mapping_a_container_from_a_container_builder : concern_for_con private IParameter _parameterBuilder; private IParameter _clonedParameter; private IContainer _result; + private SimulationBuilder _simulationBuilder; protected override void Context() { @@ -39,13 +40,14 @@ protected override void Context() _clonedContainer = new Container(); _clonedParameter = new Parameter().WithName("toto"); _clonedContainer.Add(_clonedParameter); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); A.CallTo(() => _cloneManagerForModel.Clone(_containerBuilder)).Returns(_clonedContainer); } protected override void Because() { - _result = sut.MapFrom(_containerBuilder, _simulationConfiguration); + _result = sut.MapFrom(_containerBuilder, _simulationBuilder); } [Observation] @@ -57,7 +59,7 @@ public void should_return_a_clone_from_the_given_container_ready_to_be_used_in_t [Observation] public void should_have_referenced_the_parameter_with_the_parameter_builder() { - _simulationConfiguration.BuilderFor(_clonedParameter).ShouldBeEqualTo(_parameterBuilder); + _simulationBuilder.BuilderFor(_clonedParameter).ShouldBeEqualTo(_parameterBuilder); } } } \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/FormulaBuilderToFormulaMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/FormulaBuilderToFormulaMapperSpecs.cs index 74ff7bcff..23bce0374 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/FormulaBuilderToFormulaMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/FormulaBuilderToFormulaMapperSpecs.cs @@ -5,11 +5,10 @@ using OSPSuite.Core.Domain.Formulas; using OSPSuite.Core.Domain.Mappers; using OSPSuite.Core.Domain.Services; -using OSPSuite.Helpers; namespace OSPSuite.Core.Mappers { - public abstract class concern_for_FormulaBuilderToFormulaMapper : ContextSpecification + internal abstract class concern_for_FormulaBuilderToFormulaMapper : ContextSpecification { protected ICloneManagerForModel _cloneManagerForModel; @@ -20,26 +19,28 @@ protected override void Context() } } - public class When_mapping_a_formula_from_a_formula_builder : concern_for_FormulaBuilderToFormulaMapper + internal class When_mapping_a_formula_from_a_formula_builder : concern_for_FormulaBuilderToFormulaMapper { protected IFormula _mappedFormula; protected IFormula _formula; private IFormula _clonedFormula; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _formula = A.Fake(); _clonedFormula = A.Fake(); A.CallTo(() => _cloneManagerForModel.Clone(_formula)).Returns(_clonedFormula); - A.CallTo(() => _cloneManagerForModel.Clone((IFormula)null)).Returns(null); + A.CallTo(() => _cloneManagerForModel.Clone((IFormula) null)).Returns(null); } protected override void Because() { - _mappedFormula = sut.MapFrom(_formula, _simulationConfiguration); + _mappedFormula = sut.MapFrom(_formula, _simulationBuilder); } [Observation] @@ -51,7 +52,7 @@ public void should_return_a_clone_of_the_given_formula() [Observation] public void should_return_null_if_the_given_formula_was_null() { - sut.MapFrom(null, _simulationConfiguration).ShouldBeNull(); + sut.MapFrom(null, _simulationBuilder).ShouldBeNull(); } } } \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/MoleculeBuilderToMoleculeAmountMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/MoleculeBuilderToMoleculeAmountMapperSpecs.cs index 795a38282..d70ac9534 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/MoleculeBuilderToMoleculeAmountMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/MoleculeBuilderToMoleculeAmountMapperSpecs.cs @@ -12,7 +12,7 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_MoleculeBuilderToMoleculeAmountMapper : ContextSpecification + internal abstract class concern_for_MoleculeBuilderToMoleculeAmountMapper : ContextSpecification { protected IFormulaBuilderToFormulaMapper _formulaMapper; protected IObjectBaseFactory _objectBaseFactory; @@ -35,11 +35,11 @@ protected override void Context() sut = new MoleculeBuilderToMoleculeAmountMapper(_objectBaseFactory, _formulaMapper, _parameterMapper, _dimensionFactory, _keywordReplacerTask, _formulaFactory, _parameterFactory); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); } } - public class When_mapping_a_molecule_builder_to_a_molecule_amount : concern_for_MoleculeBuilderToMoleculeAmountMapper + internal class When_mapping_a_molecule_builder_to_a_molecule_amount : concern_for_MoleculeBuilderToMoleculeAmountMapper { private IMoleculeBuilder _moleculeBuilder; private IMoleculeAmount _moleculeAmount; @@ -52,6 +52,7 @@ public class When_mapping_a_molecule_builder_to_a_molecule_amount : concern_for_ private IParameter _parameterBuilder1; private IParameter _parameterBuilder2; private IParameter _parameterBuilder3; + private SimulationBuilder _simulationBuilder; protected override void Context() { @@ -76,15 +77,16 @@ protected override void Context() _para3 = new Parameter().WithName("P3"); A.CallTo(() => _objectBaseFactory.Create()).Returns(new MoleculeAmount()); A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.MOLAR_AMOUNT)).Returns(_amountDimension); - A.CallTo(() => _formulaMapper.MapFrom(_moleculeBuilder.DefaultStartFormula, _simulationConfiguration)).Returns(_mappedFormula); - A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder1, _simulationConfiguration)).Returns(_para1); - A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder2, _simulationConfiguration)).Returns(_para2); - A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder3, _simulationConfiguration)).Returns(_para3); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); + A.CallTo(() => _formulaMapper.MapFrom(_moleculeBuilder.DefaultStartFormula, _simulationBuilder)).Returns(_mappedFormula); + A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder1, _simulationBuilder)).Returns(_para1); + A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder2, _simulationBuilder)).Returns(_para2); + A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder3, _simulationBuilder)).Returns(_para3); } protected override void Because() { - _moleculeAmount = sut.MapFrom(_moleculeBuilder, _targetContainer, _simulationConfiguration); + _moleculeAmount = sut.MapFrom(_moleculeBuilder, _targetContainer, _simulationBuilder); } [Observation] @@ -109,7 +111,7 @@ public void should_have_created_all_the_local_parameters_for_the_molecule_matchi [Observation] public void should_add_the_builder_to_the_build_configuration_cache() { - _simulationConfiguration.BuilderFor(_moleculeAmount).ShouldBeEqualTo(_moleculeBuilder); + _simulationBuilder.BuilderFor(_moleculeAmount).ShouldBeEqualTo(_moleculeBuilder); } [Observation] @@ -119,7 +121,7 @@ public void should_replace_keywords_including_molecule() } } - public class When_mapping_a_molecule_builder_using_concentration_to_a_molecule_amount : concern_for_MoleculeBuilderToMoleculeAmountMapper + internal class When_mapping_a_molecule_builder_using_concentration_to_a_molecule_amount : concern_for_MoleculeBuilderToMoleculeAmountMapper { private IMoleculeBuilder _moleculeBuilder; private IMoleculeAmount _moleculeAmount; @@ -127,6 +129,7 @@ public class When_mapping_a_molecule_builder_using_concentration_to_a_molecule_a private IDimension _concentrationDimension; private IFormula _startValueReferenceFormula; private IContainer _targetContainer; + private SimulationBuilder _simulationBuilder; protected override void Context() { @@ -138,7 +141,8 @@ protected override void Context() _moleculeBuilder = A.Fake().WithDimension(_concentrationDimension); _moleculeBuilder.DisplayUnit = A.Fake(); _mappedFormula = A.Fake(); - A.CallTo(() => _formulaMapper.MapFrom(_moleculeBuilder.DefaultStartFormula, _simulationConfiguration)).Returns(_mappedFormula); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); + A.CallTo(() => _formulaMapper.MapFrom(_moleculeBuilder.DefaultStartFormula, _simulationBuilder)).Returns(_mappedFormula); A.CallTo(() => _objectBaseFactory.Create()).ReturnsLazily(() => new MoleculeAmount()); var startValueParameter = new Parameter().WithName(Constants.Parameters.START_VALUE); A.CallTo(() => _parameterFactory.CreateStartValueParameter(A._, _mappedFormula, _moleculeBuilder.DisplayUnit)).Returns(startValueParameter); @@ -147,7 +151,7 @@ protected override void Context() protected override void Because() { - _moleculeAmount = sut.MapFrom(_moleculeBuilder, _targetContainer, _simulationConfiguration); + _moleculeAmount = sut.MapFrom(_moleculeBuilder, _targetContainer, _simulationBuilder); } [Observation] diff --git a/tests/OSPSuite.Core.Tests/Mappers/NeighborhoodBuilderToNeighborhoodMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/NeighborhoodBuilderToNeighborhoodMapperSpecs.cs index 678db5dca..a172ddb3a 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/NeighborhoodBuilderToNeighborhoodMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/NeighborhoodBuilderToNeighborhoodMapperSpecs.cs @@ -10,7 +10,7 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_NeighborhoodBuilderToNeighborhoodMapper : ContextSpecification + internal abstract class concern_for_NeighborhoodBuilderToNeighborhoodMapper : ContextSpecification { protected IContainerBuilderToContainerMapper _containerMapper; protected IObjectBaseFactory _objectBaseFactory; @@ -29,7 +29,7 @@ protected override void Context() } } - public class When_mapping_a_neighborhood_builder_to_a_neighborhood : concern_for_NeighborhoodBuilderToNeighborhoodMapper + internal class When_mapping_a_neighborhood_builder_to_a_neighborhood : concern_for_NeighborhoodBuilderToNeighborhoodMapper { private NeighborhoodBuilder _neighborhoodBuilder; private Neighborhood _neighborhood; @@ -44,12 +44,13 @@ public class When_mapping_a_neighborhood_builder_to_a_neighborhood : concern_for private IContainer _secondNeighborInModel; private SimulationConfiguration _simulationConfiguration; private IContainer _moleculeContainer; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); _rootContainer = A.Fake().WithName("ROOT"); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); _model = A.Fake(); _model.Root = _rootContainer; _neighborhoodBuilder =new NeighborhoodBuilder().WithName("tralala"); @@ -72,18 +73,19 @@ protected override void Context() A.CallTo(() => firstNeighborModelPath.Resolve(_rootContainer)).Returns(_firstNeighborInModel); A.CallTo(() => secondNeighborModelPath.Resolve(_rootContainer)).Returns(_secondNeighborInModel); _moleculeContainer = A.Fake(); - A.CallTo(() => _containerMapper.MapFrom(_neighborhoodBuilder.MoleculeProperties, _simulationConfiguration)).Returns(_moleculeContainer); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); + A.CallTo(() => _containerMapper.MapFrom(_neighborhoodBuilder.MoleculeProperties, _simulationBuilder)).Returns(_moleculeContainer); _molecule1 = "molecule1"; _molecule2 = "molecule2"; _moleculeNames = new List {_molecule1, _molecule2}; A.CallTo(() => _objectBaseFactory.Create()).Returns(new Neighborhood()); - A.CallTo(() => _parameterMapper.MapFrom(para1, _simulationConfiguration)).Returns(_clonePara1); - A.CallTo(() => _parameterMapper.MapFrom(para2, _simulationConfiguration)).Returns(_clonePara2); + A.CallTo(() => _parameterMapper.MapFrom(para1, _simulationBuilder)).Returns(_clonePara1); + A.CallTo(() => _parameterMapper.MapFrom(para2, _simulationBuilder)).Returns(_clonePara2); } protected override void Because() { - _neighborhood = sut.MapFrom(_neighborhoodBuilder, _moleculeNames, _moleculeNames, new ModelConfiguration(_model, _simulationConfiguration)); + _neighborhood = sut.MapFrom(_neighborhoodBuilder, _moleculeNames, _moleculeNames, new ModelConfiguration(_model, _simulationConfiguration, _simulationBuilder)); } [Observation] diff --git a/tests/OSPSuite.Core.Tests/Mappers/ObserverBuilderToObserverMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/ObserverBuilderToObserverMapperSpecs.cs index 69cda64fd..4478d53ce 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/ObserverBuilderToObserverMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/ObserverBuilderToObserverMapperSpecs.cs @@ -6,11 +6,10 @@ using OSPSuite.Core.Domain.Formulas; using OSPSuite.Core.Domain.Mappers; using OSPSuite.Core.Domain.UnitSystem; -using OSPSuite.Helpers; namespace OSPSuite.Core.Mappers { - public abstract class concern_for_ObserverBuilderToObserverMapper : ContextSpecification + internal abstract class concern_for_ObserverBuilderToObserverMapper : ContextSpecification { protected IObjectBaseFactory _objectBaseFactory; protected IFormulaBuilderToFormulaMapper _formulaMapper; @@ -19,32 +18,35 @@ protected override void Context() { _objectBaseFactory = A.Fake(); _formulaMapper = A.Fake(); - sut = new ObserverBuilderToObserverMapper(_objectBaseFactory,_formulaMapper); + sut = new ObserverBuilderToObserverMapper(_objectBaseFactory, _formulaMapper); } } - - public class When_mapping_an_observer_from_an_observer_builder : concern_for_ObserverBuilderToObserverMapper - { + internal class When_mapping_an_observer_from_an_observer_builder : concern_for_ObserverBuilderToObserverMapper + { private IObserverBuilder _observerBuilder; private IFormula _mappedFormula; private IObserver _observer; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _observerBuilder = A.Fake().WithName("toto").WithDimension(A.Fake()); _observerBuilder.Formula = A.Fake(); _mappedFormula = A.Fake(); - A.CallTo(()=>_objectBaseFactory.Create()).Returns(A.Fake()); - A.CallTo(() => _formulaMapper.MapFrom(_observerBuilder.Formula, _simulationConfiguration)).Returns(_mappedFormula); + A.CallTo(() => _objectBaseFactory.Create()).Returns(A.Fake()); + A.CallTo(() => _formulaMapper.MapFrom(_observerBuilder.Formula, _simulationBuilder)).Returns(_mappedFormula); } + protected override void Because() { - _observer = sut.MapFrom(_observerBuilder,_simulationConfiguration); + _observer = sut.MapFrom(_observerBuilder, _simulationBuilder); } + [Observation] public void should_return_an_observer_whose_name_was_set_to_the_name_of_the_observer() { @@ -54,8 +56,9 @@ public void should_return_an_observer_whose_name_was_set_to_the_name_of_the_obse [Observation] public void should_return_an_observer_whose_formula_was_set_to_the_mapped_formula_of_the_builder() { - _observer.Formula.ShouldBeEqualTo(_mappedFormula); + _observer.Formula.ShouldBeEqualTo(_mappedFormula); } + [Observation] public void should_return_an_observer_whose_dimension_was_set_to_the_dimension_of_the_builder() { @@ -65,8 +68,7 @@ public void should_return_an_observer_whose_dimension_was_set_to_the_dimension_o [Observation] public void should_have_added_a_reference_to_the_observer_builder_for_the_created_observer() { - _simulationConfiguration.BuilderFor(_observer).ShouldBeEqualTo(_observerBuilder); + _simulationBuilder.BuilderFor(_observer).ShouldBeEqualTo(_observerBuilder); } } - -} \ No newline at end of file +} \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/ParameterBuilderCollectionToParameterCollectionMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/ParameterBuilderCollectionToParameterCollectionMapperSpecs.cs index f8d8c77b2..6d1b3c9ce 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/ParameterBuilderCollectionToParameterCollectionMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/ParameterBuilderCollectionToParameterCollectionMapperSpecs.cs @@ -5,11 +5,10 @@ using OSPSuite.Core.Domain; using OSPSuite.Core.Domain.Builder; using OSPSuite.Core.Domain.Mappers; -using OSPSuite.Helpers; namespace OSPSuite.Core.Mappers { - public abstract class concern_for_ParameterBuilderCollectionToParameterCollectionMapper : ContextSpecification + internal abstract class concern_for_ParameterBuilderCollectionToParameterCollectionMapper : ContextSpecification { protected IParameterBuilderToParameterMapper _parameterMapper; @@ -20,8 +19,7 @@ protected override void Context() } } - - public class When_mapping_a_collection_of_parameter_builder_to_a_collection_of_parameter: concern_for_ParameterBuilderCollectionToParameterCollectionMapper + internal class When_mapping_a_collection_of_parameter_builder_to_a_collection_of_parameter : concern_for_ParameterBuilderCollectionToParameterCollectionMapper { private IList _allParameterBuilders; private IEnumerable _results; @@ -31,28 +29,32 @@ public class When_mapping_a_collection_of_parameter_builder_to_a_collection_of_p private IParameter _mappedPara1; private IParameter _mappedPara3; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); - _para1 =A.Fake().WithMode(ParameterBuildMode.Local); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); + _para1 = A.Fake().WithMode(ParameterBuildMode.Local); _para2 = A.Fake().WithMode(ParameterBuildMode.Global); _para3 = A.Fake().WithMode(ParameterBuildMode.Property); - _allParameterBuilders= new List{_para1,_para2,_para3}; - _mappedPara1 =A.Fake(); + _allParameterBuilders = new List {_para1, _para2, _para3}; + _mappedPara1 = A.Fake(); _mappedPara3 = A.Fake(); - A.CallTo(() => _parameterMapper.MapFrom(_para1,_simulationConfiguration)).Returns(_mappedPara1); - A.CallTo(() => _parameterMapper.MapFrom(_para3, _simulationConfiguration)).Returns(_mappedPara3); + A.CallTo(() => _parameterMapper.MapFrom(_para1, _simulationBuilder)).Returns(_mappedPara1); + A.CallTo(() => _parameterMapper.MapFrom(_para3, _simulationBuilder)).Returns(_mappedPara3); } + protected override void Because() { - _results = sut.MapFrom(_allParameterBuilders,_simulationConfiguration, ParameterBuildMode.Local, ParameterBuildMode.Property); + _results = sut.MapFrom(_allParameterBuilders, _simulationBuilder, ParameterBuildMode.Local, ParameterBuildMode.Property); } + [Observation] public void should_only_return_the_parameters_matching_the_given_mode() { - _results.ShouldOnlyContain(_mappedPara1,_mappedPara3); + _results.ShouldOnlyContain(_mappedPara1, _mappedPara3); } } -} \ No newline at end of file +} \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/ReactionBuilderToReactionMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/ReactionBuilderToReactionMapperSpecs.cs index 18a444e80..fa8a27605 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/ReactionBuilderToReactionMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/ReactionBuilderToReactionMapperSpecs.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using FakeItEasy; using OSPSuite.BDDHelper; @@ -10,7 +11,7 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_ReactionBuilderToReactionMapper : ContextSpecification + internal abstract class concern_for_ReactionBuilderToReactionMapper : ContextSpecification { protected IReactionPartnerBuilderToReactionPartnerMapper _reactionPartnerMapper; protected IObjectBaseFactory _objectBaseFactory; @@ -29,6 +30,7 @@ public abstract class concern_for_ReactionBuilderToReactionMapper : ContextSpeci private IDimensionFactory _dimensionFactory; protected IDimension _amountPerTimeDimension; protected IDimension _concentrationPerTimeDimension; + protected SimulationBuilder _simulationBuilder; protected override void Context() { @@ -41,7 +43,7 @@ protected override void Context() _objectBaseFactory = A.Fake(); _formulaMapper = A.Fake(); _parameterMapper = A.Fake(); - _dimensionFactory= A.Fake(); + _dimensionFactory = A.Fake(); _modifier = "MOD"; _reactionBuilder = A.Fake().WithName("MyReaction"); _reactionBuilder.Dimension = _amountPerTimeDimension; @@ -56,28 +58,29 @@ protected override void Context() _educt2 = A.Fake(); _prod2 = A.Fake(); _container = A.Fake(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.AMOUNT_PER_TIME)).Returns(_amountPerTimeDimension); - A.CallTo(() => _reactionPartnerMapper.MapFromLocal(edPartner1, _container, _simulationConfiguration)).Returns(_educt1); - A.CallTo(() => _reactionPartnerMapper.MapFromLocal(edPartner2, _container, _simulationConfiguration)).Returns(_educt2); - A.CallTo(() => _reactionPartnerMapper.MapFromLocal(prodPartner1, _container, _simulationConfiguration)).Returns(_prod1); - A.CallTo(() => _reactionPartnerMapper.MapFromLocal(prodPartner2, _container, _simulationConfiguration)).Returns(_prod2); - A.CallTo(() => _formulaMapper.MapFrom(_reactionBuilder.Formula, _simulationConfiguration)).Returns(_reactionBuilder.Formula); - A.CallTo(() => _reactionBuilder.Educts).Returns(new[] { edPartner1, edPartner2 }); - A.CallTo(() => _reactionBuilder.Products).Returns(new[] { prodPartner1, prodPartner2 }); - A.CallTo(() => _reactionBuilder.Parameters).Returns(new IParameter[0]); - A.CallTo(() => _reactionBuilder.ModifierNames).Returns(new[] { _modifier }); + A.CallTo(() => _reactionPartnerMapper.MapFromLocal(edPartner1, _container, _simulationBuilder)).Returns(_educt1); + A.CallTo(() => _reactionPartnerMapper.MapFromLocal(edPartner2, _container, _simulationBuilder)).Returns(_educt2); + A.CallTo(() => _reactionPartnerMapper.MapFromLocal(prodPartner1, _container, _simulationBuilder)).Returns(_prod1); + A.CallTo(() => _reactionPartnerMapper.MapFromLocal(prodPartner2, _container, _simulationBuilder)).Returns(_prod2); + A.CallTo(() => _formulaMapper.MapFrom(_reactionBuilder.Formula, _simulationBuilder)).Returns(_reactionBuilder.Formula); + A.CallTo(() => _reactionBuilder.Educts).Returns(new[] {edPartner1, edPartner2}); + A.CallTo(() => _reactionBuilder.Products).Returns(new[] {prodPartner1, prodPartner2}); + A.CallTo(() => _reactionBuilder.Parameters).Returns(Array.Empty()); + A.CallTo(() => _reactionBuilder.ModifierNames).Returns(new[] {_modifier}); A.CallTo(() => _objectBaseFactory.Create()).Returns(new Reaction()); - A.CallTo(() => _parameterMapper.MapFrom(_reactionBuilder.Parameters, _simulationConfiguration, ParameterBuildMode.Local)).Returns(new List()); - _processRateParameterCreator = new ProcessRateParameterCreator(_objectBaseFactory,_formulaMapper); - sut = new ReactionBuilderToReactionMapper(_objectBaseFactory, _reactionPartnerMapper, _formulaMapper, _parameterMapper,_processRateParameterCreator); + A.CallTo(() => _parameterMapper.MapFrom(_reactionBuilder.Parameters, _simulationBuilder, ParameterBuildMode.Local)).Returns(new List()); + _processRateParameterCreator = new ProcessRateParameterCreator(_objectBaseFactory, _formulaMapper); + sut = new ReactionBuilderToReactionMapper(_objectBaseFactory, _reactionPartnerMapper, _formulaMapper, _parameterMapper, _processRateParameterCreator); } } - public class When_mapping_a_reaction_builder_to_a_reaction : concern_for_ReactionBuilderToReactionMapper + internal class When_mapping_a_reaction_builder_to_a_reaction : concern_for_ReactionBuilderToReactionMapper { protected override void Because() { - _reaction = sut.MapFromLocal(_reactionBuilder, _container, _simulationConfiguration); + _reaction = sut.MapFromLocal(_reactionBuilder, _container, _simulationBuilder); } [Observation] @@ -103,7 +106,7 @@ public void should_have_updated_the_formula_according_to_the_defined_kinetic_in_ { _reaction.Formula.ShouldBeEqualTo(_reactionBuilder.Formula); } - + [Observation] public void should_return_a_reaction_with_the_modifiers_initialized_as_specified_in_the_builder() { @@ -117,8 +120,7 @@ public void should_return_a_reaction_with_the_dimension_set_to_amount_per_time() } } - - public class When_mapping_a_reaction_builder_to_a_reaction_for_which_a_parameter_rate_should_be_generated : concern_for_ReactionBuilderToReactionMapper + internal class When_mapping_a_reaction_builder_to_a_reaction_for_which_a_parameter_rate_should_be_generated : concern_for_ReactionBuilderToReactionMapper { private IFormula _kinetic; private IParameter _processRateParameter; @@ -130,18 +132,17 @@ protected override void Context() _kinetic = A.Fake(); _reactionBuilder.CreateProcessRateParameter = true; _reactionBuilder.ProcessRateParameterPersistable = true; - A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _simulationConfiguration)).ReturnsLazily(x => new ExplicitFormula("clone")); + A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _simulationBuilder)).ReturnsLazily(x => new ExplicitFormula("clone")); _reactionBuilder.Name = "Reaction"; _reactionBuilder.Formula = _kinetic; - A.CallTo(() => _parameterMapper.MapFrom(_reactionBuilder.Parameters, _simulationConfiguration)).Returns(new List()); + A.CallTo(() => _parameterMapper.MapFrom(_reactionBuilder.Parameters, _simulationBuilder)).Returns(new List()); _processRateParameter = new Parameter(); A.CallTo(() => _objectBaseFactory.Create()).Returns(_processRateParameter); - } protected override void Because() { - _reaction = sut.MapFromLocal(_reactionBuilder,_container, _simulationConfiguration); + _reaction = sut.MapFromLocal(_reactionBuilder, _container, _simulationBuilder); _processRateParameter = _reaction.GetSingleChildByName(Constants.Parameters.PROCESS_RATE); } @@ -156,6 +157,5 @@ public void created_Parameter_should_be_persistable() { _processRateParameter.Persistable.ShouldBeTrue(); } - } } \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/ReactionPartnerBuilderToReactionPartnerMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/ReactionPartnerBuilderToReactionPartnerMapperSpecs.cs index 7e1c29bb8..81e949c3c 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/ReactionPartnerBuilderToReactionPartnerMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/ReactionPartnerBuilderToReactionPartnerMapperSpecs.cs @@ -8,7 +8,7 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_reaction_partner_builder_to_reaction_partner_mapper : ContextSpecification + internal abstract class concern_for_reaction_partner_builder_to_reaction_partner_mapper : ContextSpecification { protected override void Context() { @@ -16,19 +16,21 @@ protected override void Context() } } - public class When_mapping_a_reaction_partner_builder_to_a_reaction_partner : concern_for_reaction_partner_builder_to_reaction_partner_mapper + internal class When_mapping_a_reaction_partner_builder_to_a_reaction_partner : concern_for_reaction_partner_builder_to_reaction_partner_mapper { private IReactionPartnerBuilder _reactionPartnerBuilder; private IReactionPartner _reactionPartner; private IContainer _container; private IMoleculeAmount _moleculeAmount; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); _reactionPartnerBuilder = A.Fake(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _container = new Container(); _reactionPartnerBuilder.MoleculeName = "Drug"; _moleculeAmount = A.Fake().WithName("Drug"); @@ -38,7 +40,7 @@ protected override void Context() protected override void Because() { - _reactionPartner = sut.MapFromLocal(_reactionPartnerBuilder, _container, _simulationConfiguration); + _reactionPartner = sut.MapFromLocal(_reactionPartnerBuilder, _container, _simulationBuilder); } [Observation] @@ -54,18 +56,20 @@ public void should_have_set_the_partner_property_to_molecule_amount() } } - public class When_mapping_a_reaction_partner_builder_to_a_reaction_partner_missing_a_amount : concern_for_reaction_partner_builder_to_reaction_partner_mapper + internal class When_mapping_a_reaction_partner_builder_to_a_reaction_partner_missing_a_amount : concern_for_reaction_partner_builder_to_reaction_partner_mapper { private IReactionPartnerBuilder _reactionPartnerBuilder; private IContainer _container; private SimulationConfiguration _simulationConfiguration; + private SimulationBuilder _simulationBuilder; protected override void Context() { base.Context(); _reactionPartnerBuilder = A.Fake(); _container = new Container(); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _reactionPartnerBuilder.MoleculeName = "Drug"; _reactionPartnerBuilder.StoichiometricCoefficient = 1.1; } @@ -73,7 +77,7 @@ protected override void Context() [Observation] public void should_throw_a_MissingMoleculeAmountException() { - The.Action(() => sut.MapFromLocal(_reactionPartnerBuilder, _container, _simulationConfiguration)).ShouldThrowAn(); + The.Action(() => sut.MapFromLocal(_reactionPartnerBuilder, _container, _simulationBuilder)).ShouldThrowAn(); } } } \ No newline at end of file diff --git a/tests/OSPSuite.Core.Tests/Mappers/TransportBuilderToTransportMapperSpecs.cs b/tests/OSPSuite.Core.Tests/Mappers/TransportBuilderToTransportMapperSpecs.cs index dbf45110c..56b981381 100644 --- a/tests/OSPSuite.Core.Tests/Mappers/TransportBuilderToTransportMapperSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Mappers/TransportBuilderToTransportMapperSpecs.cs @@ -12,17 +12,19 @@ namespace OSPSuite.Core.Mappers { - public abstract class concern_for_TransportBuilderToTransportMapper : ContextSpecification + internal abstract class concern_for_TransportBuilderToTransportMapper : ContextSpecification { protected IObjectBaseFactory _objectBaseFactory; protected IFormulaBuilderToFormulaMapper _formulaBuilderToFormulaMapper; protected IParameterBuilderCollectionToParameterCollectionMapper _parameterMapper; protected SimulationConfiguration _simulationConfiguration; protected IProcessRateParameterCreator _processRateParameterCreator; + protected SimulationBuilder _simulationBuilder; protected override void Context() { - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); _objectBaseFactory = A.Fake(); A.CallTo(() => _objectBaseFactory.Create()).Returns(new Transport()); _formulaBuilderToFormulaMapper = A.Fake(); @@ -32,7 +34,7 @@ protected override void Context() } } - public class When_mapping_a_transport_builder_to_a_transport : concern_for_TransportBuilderToTransportMapper + internal class When_mapping_a_transport_builder_to_a_transport : concern_for_TransportBuilderToTransportMapper { private ITransportBuilder _passiveTransportBuilder; private IFormula _kinetic; @@ -43,15 +45,15 @@ protected override void Context() base.Context(); _passiveTransportBuilder = new TransportBuilder {TransportType = TransportType.Efflux}; _kinetic = A.Fake(); - A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationConfiguration)).Returns(_kinetic); + A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationBuilder)).Returns(_kinetic); _passiveTransportBuilder.Name = "PassiveTransport"; _passiveTransportBuilder.Formula = _kinetic; - A.CallTo(() => _parameterMapper.MapFrom(_passiveTransportBuilder.Parameters, _simulationConfiguration)).Returns(new List()); + A.CallTo(() => _parameterMapper.MapFrom(_passiveTransportBuilder.Parameters, _simulationBuilder)).Returns(new List()); } protected override void Because() { - _transport = sut.MapFrom(_passiveTransportBuilder, _simulationConfiguration); + _transport = sut.MapFrom(_passiveTransportBuilder, _simulationBuilder); } [Observation] @@ -69,11 +71,11 @@ public void should_have_returned_a_transport_with_formula_property_set_to_builde [Observation] public void should_have_added_the_transport_builder_as_reference_to_the_transport() { - _simulationConfiguration.BuilderFor(_transport).ShouldBeEqualTo(_passiveTransportBuilder); + _simulationBuilder.BuilderFor(_transport).ShouldBeEqualTo(_passiveTransportBuilder); } } - public class When_mapping_an_active_influx_transport_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper + internal class When_mapping_an_active_influx_transport_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper { private ITransportBuilder _transportBuilder; private IFormula _kinetic; @@ -86,19 +88,19 @@ protected override void Context() _transportBuilder = new TransportBuilder(); _kinetic = A.Fake(); _transportBuilder.CreateProcessRateParameter = true; - A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationConfiguration)).ReturnsLazily(x => new ExplicitFormula("clone")); + A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationBuilder)).ReturnsLazily(x => new ExplicitFormula("clone")); _transportBuilder.TransportType = TransportType.Influx; _transportBuilder.Name = "Active Transport"; _transportBuilder.Formula = _kinetic; - A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationConfiguration)).Returns(new List()); + A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationBuilder)).Returns(new List()); _processRateParameter = new Parameter(); A.CallTo(() => _objectBaseFactory.Create()).Returns(_processRateParameter); } protected override void Because() { - _transport = sut.MapFrom(_transportBuilder, _simulationConfiguration); + _transport = sut.MapFrom(_transportBuilder, _simulationBuilder); _processRateParameter = _transport.GetSingleChildByName(Constants.Parameters.PROCESS_RATE); } @@ -152,7 +154,7 @@ public void the_formula_of_the_process_rate_parameter_should_have_been_set_to_a_ } } - public class When_mapping_an_active_efflux_transport_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper + internal class When_mapping_an_active_efflux_transport_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper { private ITransportBuilder _transportBuilder; private IFormula _kinetic; @@ -165,19 +167,19 @@ protected override void Context() _transportBuilder = new TransportBuilder(); _kinetic = A.Fake(); _transportBuilder.CreateProcessRateParameter = true; - A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationConfiguration)).ReturnsLazily(x => new ExplicitFormula("clone")); + A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationBuilder)).ReturnsLazily(x => new ExplicitFormula("clone")); _transportBuilder.TransportType = TransportType.Efflux; _transportBuilder.Name = "Active Transport"; _transportBuilder.Formula = _kinetic; - A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationConfiguration)).Returns(new List()); + A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationBuilder)).Returns(new List()); _processRateParameter = new Parameter(); A.CallTo(() => _objectBaseFactory.Create()).Returns(_processRateParameter); } protected override void Because() { - _transport = sut.MapFrom(_transportBuilder, _simulationConfiguration); + _transport = sut.MapFrom(_transportBuilder, _simulationBuilder); _processRateParameter = _transport.GetSingleChildByName(Constants.Parameters.PROCESS_RATE); } @@ -237,7 +239,7 @@ public void the_formula_of_the_process_rate_parameter_should_have_been_set_to_a_ } } - public class When_mapping_a_passive_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper + internal class When_mapping_a_passive_builder_to_a_transport_for_which_a_parameter_rate_should_be_generated : concern_for_TransportBuilderToTransportMapper { private ITransportBuilder _transportBuilder; private IFormula _kinetic; @@ -250,19 +252,19 @@ protected override void Context() _transportBuilder = new TransportBuilder(); _kinetic = A.Fake(); _transportBuilder.CreateProcessRateParameter = true; - A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationConfiguration)).ReturnsLazily(x => new ExplicitFormula("clone")); + A.CallTo(() => _formulaBuilderToFormulaMapper.MapFrom(_kinetic, _simulationBuilder)).ReturnsLazily(x => new ExplicitFormula("clone")); _transportBuilder.TransportType = TransportType.Diffusion; _transportBuilder.Name = "PassiveTransport"; _transportBuilder.Formula = _kinetic; - A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationConfiguration)).Returns(new List()); + A.CallTo(() => _parameterMapper.MapFrom(_transportBuilder.Parameters, _simulationBuilder)).Returns(new List()); _processRateParameter = new Parameter(); A.CallTo(() => _objectBaseFactory.Create()).Returns(_processRateParameter); } protected override void Because() { - _transport = sut.MapFrom(_transportBuilder, _simulationConfiguration); + _transport = sut.MapFrom(_transportBuilder, _simulationBuilder); _processRateParameter = _transport.GetSingleChildByName(Constants.Parameters.PROCESS_RATE); } diff --git a/tests/OSPSuite.Core.Tests/Services/CircularReferenceCheckerSpecs.cs b/tests/OSPSuite.Core.Tests/Services/CircularReferenceCheckerSpecs.cs index e99c9879e..5a510f57a 100644 --- a/tests/OSPSuite.Core.Tests/Services/CircularReferenceCheckerSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Services/CircularReferenceCheckerSpecs.cs @@ -10,7 +10,7 @@ namespace OSPSuite.Core.Services { - public abstract class concern_for_CircularReferenceChecker : ContextSpecification + internal abstract class concern_for_CircularReferenceChecker : ContextSpecification { protected IFormula _formula; protected List _objectPaths; @@ -31,7 +31,7 @@ protected override void Context() } } - public class When_checking_a_time_reference : concern_for_CircularReferenceChecker + internal class When_checking_a_time_reference : concern_for_CircularReferenceChecker { private bool _result; @@ -47,7 +47,7 @@ public void should_always_return_no_circular_references() } } - public class When_checking_a_self_reference : concern_for_CircularReferenceChecker + internal class When_checking_a_self_reference : concern_for_CircularReferenceChecker { private bool _result; private FormulaUsablePath _path; @@ -72,7 +72,7 @@ public void should_always_return_circular_references() } } - public class When_checking_a_two_step_reference : concern_for_CircularReferenceChecker + internal class When_checking_a_two_step_reference : concern_for_CircularReferenceChecker { private bool _result; private FormulaUsablePath _path; @@ -108,7 +108,7 @@ public void should_always_return_circular_references() } } - public abstract class When_checking_a_simple_tree_structure : concern_for_CircularReferenceChecker + internal abstract class When_checking_a_simple_tree_structure : concern_for_CircularReferenceChecker { private Container _container; private Model _model; @@ -123,7 +123,8 @@ protected override void Context() protected override void Because() { - _result = sut.CheckCircularReferencesIn(new ModelConfiguration(_model, new SimulationConfigurationForSpecs())); + var simulationConfiguration = new SimulationConfiguration(); + _result = sut.CheckCircularReferencesIn(new ModelConfiguration(_model, simulationConfiguration, new SimulationBuilder(simulationConfiguration))); } protected Parameter CreateParameter(string name, string objectPath) @@ -140,7 +141,7 @@ protected Parameter CreateParameter(string name, string objectPath) } } - public class When_checking_a_simple_tree_structure_without_circular_references : When_checking_a_simple_tree_structure + internal class When_checking_a_simple_tree_structure_without_circular_references : When_checking_a_simple_tree_structure { protected override void Context() { @@ -160,7 +161,7 @@ public void should_return_no_circular_references() } } - public class When_checking_a_simple_tree_structure_with_circular_references : When_checking_a_simple_tree_structure + internal class When_checking_a_simple_tree_structure_with_circular_references : When_checking_a_simple_tree_structure { protected override void Context() { @@ -177,7 +178,7 @@ public void should_return_no_circular_references() } } - public abstract class When_checking_circular_references_in_a_model : concern_for_CircularReferenceChecker + internal abstract class When_checking_circular_references_in_a_model : concern_for_CircularReferenceChecker { private Container _container; private Model _model; @@ -195,16 +196,16 @@ protected override void Context() _model = new Model {Root = new ARootContainer {_container}.WithName("ROOT")}; _container.Add(_parameter1); _container.Add(_parameter2); - _simulationConfiguration = new SimulationConfigurationForSpecs(); + _simulationConfiguration = new SimulationConfiguration(); } protected override void Because() { - _results = sut.CheckCircularReferencesIn(new ModelConfiguration(_model, _simulationConfiguration)); + _results = sut.CheckCircularReferencesIn(new ModelConfiguration(_model, _simulationConfiguration, new SimulationBuilder(_simulationConfiguration))); } } - public class When_validating_the_references_used_in_a_quantity_resulting_in_formula_with_circular_references : When_checking_circular_references_in_a_model + internal class When_validating_the_references_used_in_a_quantity_resulting_in_formula_with_circular_references : When_checking_circular_references_in_a_model { protected override void Context() { @@ -226,7 +227,7 @@ public void should_return_the_expected_results() } } - public class When_validating_the_references_used_in_a_quantity_resulting_in_formula_with_a_rhs_circular_references : When_checking_circular_references_in_a_model + internal class When_validating_the_references_used_in_a_quantity_resulting_in_formula_with_a_rhs_circular_references : When_checking_circular_references_in_a_model { protected override void Context() { diff --git a/tests/OSPSuite.Core.Tests/Services/ObserverBuilderTaskSpecs.cs b/tests/OSPSuite.Core.Tests/Services/ObserverBuilderTaskSpecs.cs index 42e75fd32..db21f029a 100644 --- a/tests/OSPSuite.Core.Tests/Services/ObserverBuilderTaskSpecs.cs +++ b/tests/OSPSuite.Core.Tests/Services/ObserverBuilderTaskSpecs.cs @@ -21,19 +21,43 @@ internal abstract class concern_for_ObserverBuilderTask : ContextSpecification(); - _simulationConfiguration = A.Fake(); _observerBuildingBlock = new ObserverBuildingBlock(); - A.CallTo(() => _simulationConfiguration.Observers).ReturnsLazily(()=> _observerBuildingBlock.ToList()); + _molecule1 = new MoleculeBuilder().WithName(_molecule1Name); + _molecule2 = new MoleculeBuilder().WithName(_molecule2Name); + _moleculeBuildingBlock = new MoleculeBuildingBlock + { + _molecule1, _molecule2 + }; + _moleculeStartValues = new MoleculeStartValuesBuildingBlock + { + new MoleculeStartValue {Path = new ObjectPath("Liver", _molecule1Name), IsPresent = true}, + new MoleculeStartValue {Path = new ObjectPath("Liver", _molecule2Name), IsPresent = true}, + }; + + var module = new Module + { + Observers = _observerBuildingBlock, + Molecules = _moleculeBuildingBlock, + }; + module.AddMoleculeStartValueBlock(_moleculeStartValues); + _simulationConfiguration = new SimulationConfiguration(); + _simulationConfiguration.AddModuleConfiguration(new ModuleConfiguration(module)); + + _model = A.Fake(); - A.CallTo(() => _simulationConfiguration.AllPresentMolecules()).Returns(new[] {A.Fake().WithName(_molecule1), A.Fake().WithName(_molecule2)}); _rootContainer = new Container(); _organism = new Container().WithName("Organism"); @@ -50,14 +74,15 @@ protected override void Context() protected override void Because() { - sut.CreateObservers(new ModelConfiguration(_model, _simulationConfiguration)); + _simulationBuilder = new SimulationBuilder(_simulationConfiguration); + sut.CreateObservers(new ModelConfiguration(_model, _simulationConfiguration, _simulationBuilder)); } } internal class When_creating_the_container_observers_in_a_model_based_on_the_build_configuration : concern_for_ObserverBuilderTask { - private IContainerObserverBuilder _obs1; - private IContainerObserverBuilder _obs2; + private IObserverBuilder _obs1; + private IObserverBuilder _obs2; private IContainer _molecule2Amount; private IContainer _molecule1Amount; private DescriptorCriteria _observerCriteria; @@ -68,24 +93,24 @@ protected override void Context() _observerCriteria = Create.Criteria(x => x.With("Organism")); - _obs1 = A.Fake(); + _obs1 = new ContainerObserverBuilder().WithName("OBS1"); _obs1.MoleculeList.ForAll = true; _obs1.ContainerCriteria = _observerCriteria; - _obs2 = A.Fake(); + _obs2 = new ContainerObserverBuilder().WithName("OBS2"); _obs2.MoleculeList.ForAll = false; - A.CallTo(() => _obs2.MoleculeList.MoleculeNames).Returns(new List { _molecule2 }); + _obs2.AddMoleculeName(_molecule2Name); _obs2.ContainerCriteria = _observerCriteria; - _molecule2Amount = new MoleculeAmount().WithName(_molecule2); - _molecule1Amount = new MoleculeAmount().WithName(_molecule1); + _molecule1Amount = new MoleculeAmount().WithName(_molecule1Name); + _molecule2Amount = new MoleculeAmount().WithName(_molecule2Name); _organism.Add(_molecule2Amount); _organism.Add(_molecule1Amount); _observerBuildingBlock.Add(_obs1); _observerBuildingBlock.Add(_obs2); - A.CallTo(() => _observerMapper.MapFrom(_obs1, _simulationConfiguration)).Returns(A.Fake().WithName("obs1")); - A.CallTo(() => _observerMapper.MapFrom(_obs2, _simulationConfiguration)).Returns(A.Fake().WithName("obs2")); - A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_organism, _molecule1)).Returns(_molecule1Amount); - A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_organism, _molecule2)).Returns(_molecule2Amount); + A.CallTo(() => _observerMapper.MapFrom(_obs1, A._)).Returns(new Observer().WithName(_obs1.Name)); + A.CallTo(() => _observerMapper.MapFrom(_obs2, A._)).Returns(new Observer().WithName(_obs2.Name)); + A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_organism, _molecule1Name)).Returns(_molecule1Amount); + A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_organism, _molecule2Name)).Returns(_molecule2Amount); } [Observation] @@ -115,19 +140,19 @@ internal class When_creating_the_amount_observer_in_a_model_based_on_the_build_c protected override void Context() { base.Context(); - _obs1 = A.Fake(); + _obs1 = new AmountObserverBuilder().WithName("OBS1"); _obs1.MoleculeList.ForAll = true; - _obs2 = A.Fake(); + _obs2 = new AmountObserverBuilder().WithName("OBS2"); _obs2.MoleculeList.ForAll = false; - A.CallTo(() => _obs2.MoleculeList.MoleculeNames).Returns(new List { _molecule2 }); + _obs2.AddMoleculeName(_molecule2Name); _observerBuildingBlock.Add(_obs1); _observerBuildingBlock.Add(_obs2); - A.CallTo(() => _observerMapper.MapFrom(_obs1, _simulationConfiguration)).ReturnsLazily(x=> A.Fake().WithName("obs1")); - A.CallTo(() => _observerMapper.MapFrom(_obs2, _simulationConfiguration)).ReturnsLazily(x=> A.Fake().WithName("obs2")); - _molecule1Container1 = new MoleculeAmount().WithName(_molecule1).WithQuantityType(QuantityType.Drug); - _molecule2Container1 = new MoleculeAmount().WithName(_molecule2).WithQuantityType(QuantityType.Enzyme); - _molecule1Container2 = new MoleculeAmount().WithName(_molecule1).WithQuantityType(QuantityType.Drug); - _molecule2Container2 = new MoleculeAmount().WithName(_molecule2).WithQuantityType(QuantityType.Enzyme); + A.CallTo(() => _observerMapper.MapFrom(_obs1, A._)).ReturnsLazily(x => new Observer().WithName(_obs1.Name)); + A.CallTo(() => _observerMapper.MapFrom(_obs2, A._)).ReturnsLazily(x => new Observer().WithName(_obs2.Name)); + _molecule1Container1 = new MoleculeAmount().WithName(_molecule1Name).WithQuantityType(QuantityType.Drug); + _molecule2Container1 = new MoleculeAmount().WithName(_molecule2Name).WithQuantityType(QuantityType.Enzyme); + _molecule1Container2 = new MoleculeAmount().WithName(_molecule1Name).WithQuantityType(QuantityType.Drug); + _molecule2Container2 = new MoleculeAmount().WithName(_molecule2Name).WithQuantityType(QuantityType.Enzyme); var container1 = new Container().WithName("Container1"); container1.AddTag("OBS"); container1.AddTag("OBS1"); diff --git a/tests/OSPSuite.HelpersForTests/ConcentrationBaseModelHelperForSpecs.cs b/tests/OSPSuite.HelpersForTests/ConcentrationBaseModelHelperForSpecs.cs index e93f7ac4a..61f90c22f 100644 --- a/tests/OSPSuite.HelpersForTests/ConcentrationBaseModelHelperForSpecs.cs +++ b/tests/OSPSuite.HelpersForTests/ConcentrationBaseModelHelperForSpecs.cs @@ -68,7 +68,7 @@ private IModel createModel(SimulationConfiguration simulationConfiguration) private SimulationConfiguration createSimulationConfiguration() { - var simulationConfiguration = new SimulationConfigurationForSpecs(); + var simulationConfiguration = new SimulationConfiguration(); var module = new Module { @@ -87,10 +87,11 @@ private SimulationConfiguration createSimulationConfiguration() moleculeStartValues.Add(_moleculeStartValuesCreator.CreateMoleculeStartValue(objectPathForContainerThatDoesNotExist, "A", _concentrationDimension)); module.AddMoleculeStartValueBlock(moleculeStartValues); - module.AddParameterStartValueBlock(_objectBaseFactory.Create()); + var parameterStartValues = _objectBaseFactory.Create(); + module.AddParameterStartValueBlock(parameterStartValues); setMoleculeStartValues(moleculeStartValues); - var moduleConfiguration = new ModuleConfiguration(module, moleculeStartValues); + var moduleConfiguration = new ModuleConfiguration(module, moleculeStartValues, parameterStartValues); simulationConfiguration.AddModuleConfiguration(moduleConfiguration); return simulationConfiguration; } diff --git a/tests/OSPSuite.HelpersForTests/ModelHelperForSpecs.cs b/tests/OSPSuite.HelpersForTests/ModelHelperForSpecs.cs index b96527411..2b882610b 100644 --- a/tests/OSPSuite.HelpersForTests/ModelHelperForSpecs.cs +++ b/tests/OSPSuite.HelpersForTests/ModelHelperForSpecs.cs @@ -57,7 +57,7 @@ public SimulationConfiguration CreateSimulationConfiguration() module.Observers = getObservers(); module.EventGroups = getEventGroups(); - var simulationConfiguration = new SimulationConfigurationForSpecs + var simulationConfiguration = new SimulationConfiguration() { SimulationSettings = createSimulationConfiguration(), }; diff --git a/tests/OSPSuite.HelpersForTests/ModuleHelperForSpecs.cs b/tests/OSPSuite.HelpersForTests/ModuleHelperForSpecs.cs index 2309f996f..cf7a9b32d 100644 --- a/tests/OSPSuite.HelpersForTests/ModuleHelperForSpecs.cs +++ b/tests/OSPSuite.HelpersForTests/ModuleHelperForSpecs.cs @@ -26,7 +26,7 @@ public ModuleHelperForSpecs(IObjectBaseFactory objectBaseFactory, ISolverSetting public SimulationConfiguration CreateSimulationConfiguration() { - var simulationConfiguration = new SimulationConfigurationForSpecs + var simulationConfiguration = new SimulationConfiguration { SimulationSettings = createSimulationConfiguration(), }; @@ -120,7 +120,7 @@ private ISpatialStructure getSpatialStructureModule1() spatialStructure.AddTopContainer(organism); var neighborhood1 = _neighborhoodFactory.CreateBetween(artPlasma, bonePlasma).WithName("art_pls_to_bon_pls"); - //this is a constant parmaeter that will be referenced from arterial plasma compartment + //this is a constant parameter that will be referenced from arterial plasma compartment neighborhood1.AddParameter(newConstantParameter("K", 10)); spatialStructure.AddNeighborhood(neighborhood1); var neighborhood2 = _neighborhoodFactory.CreateBetween(lngPlasma, artPlasma).WithName("lng_pls_to_art_pls"); diff --git a/tests/OSPSuite.HelpersForTests/SimulationConfigurationForSpecs.cs b/tests/OSPSuite.HelpersForTests/SimulationConfigurationForSpecs.cs deleted file mode 100644 index 1fdf69f93..000000000 --- a/tests/OSPSuite.HelpersForTests/SimulationConfigurationForSpecs.cs +++ /dev/null @@ -1,15 +0,0 @@ -using OSPSuite.Core.Domain.Builder; - -namespace OSPSuite.Helpers -{ - /// - /// Same as real configuration but does not clear cache so that we can test that cache is correct - /// - public class SimulationConfigurationForSpecs : SimulationConfiguration - { - public override void ClearBuilderCache() - { - /*do nothing*/ - } - } -} \ No newline at end of file From cddde2698e56c67cccba1dfcc1e8950c0fea0829 Mon Sep 17 00:00:00 2001 From: Michael Sevestre Date: Wed, 12 Apr 2023 13:36:52 -0400 Subject: [PATCH 2/2] Fixes #1970 add simulation builder --- .../ModelConstructorIntegrationTests.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs b/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs index 59070fb14..e22064c0b 100644 --- a/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs +++ b/tests/OSPSuite.Core.IntegrationTests/ModelConstructorIntegrationTests.cs @@ -35,7 +35,6 @@ protected override void Because() { sut = IoC.Resolve(); _result = sut.CreateModelFrom(_simulationConfiguration, _modelName); - //Freeze in the test so that we can access the properties. This needs to be done AFTER the model creation _model = _result.Model; _simulationBuilder = _result.SimulationBuilder; }