public IMoBiCommand UpdateDistributedFormula(IDistributedParameter distributedParameter, IDistributionFormula newDistributedFormula, string formulaType, IBuildingBlock buildingBlock)
{
_context.Register(newDistributedFormula);
_context.Register(distributedParameter.Formula);
var command = new UpdateDistributedFormulaCommand(distributedParameter, newDistributedFormula, formulaType, buildingBlock).Run(_context);
return(withUpdatedDefaultStateAndValueOrigin(command, newDistributedFormula, buildingBlock));
}
protected override void ExecuteWith(IMoBiContext context)
{
_modelSerialization = context.Serialize(_simulationToUpdate.Model);
_buildConfigurationSerialization = context.Serialize(_simulationToUpdate.MoBiBuildConfiguration);
context.UnregisterSimulation(_simulationToUpdate);
context.PublishEvent(new SimulationUnloadEvent(_simulationToUpdate));
var oldIdCache = getEntityIdCache(_simulationToUpdate);
_simulationToUpdate.Update(_updatedBuildConfiguration, _newModel);
updateReferencesToSimulation(context);
if (_simulationToUpdate.DiagramModel != null)
{
replaceDiagramModelNodeIds(_simulationToUpdate.DiagramModel, oldIdCache, getEntityIdCache(_simulationToUpdate));
}
context.Register(_simulationToUpdate);
_wasChanged = _simulationToUpdate.HasChanged;
_simulationToUpdate.HasChanged = _hasChanged;
Description = AppConstants.Commands.UpdateCommandDescription(_changedBuildingBlockName, _simulationToUpdate, _changedBuildingBlockType);
context.PublishEvent(new SimulationReloadEvent(_simulationToUpdate));
}
public void Compute(IMoBiSimulation simulation)
{
var buildConfiguration = _buildConfigurationFactory.CreateFromReferencesUsedIn(simulation.MoBiBuildConfiguration);
buildConfiguration.ShowProgress = false;
_logger.AddDebug("Creating new simulation from loaded building blocks");
var results = _modelConstructor.CreateModelFrom(buildConfiguration, "BatchRun");
if (results.IsInvalid)
{
_logger.AddWarning(results.ValidationResult.Messages.SelectMany(x => x.Details).ToString());
}
var newSimulation = new MoBiSimulation
{
BuildConfiguration = buildConfiguration,
Model = results.Model,
Id = "Sim"
};
_context.Register(newSimulation);
_logger.AddDebug("Running simulation");
_simModelManager.RunSimulation(newSimulation);
}
private void addContainerVolumeParameter(IMoBiContext context)
{
var volume = _container.GetSingleChildByName <IParameter>(Constants.Parameters.VOLUME);
//switch from physical to logical. If volume was created here, this command is an inverse and volume should be removed
if (_newContainerMode == ContainerMode.Logical)
{
if (_volumeParameterCreatedHere && volume != null)
{
_container.RemoveChild(volume);
context.Unregister(volume);
context.PublishEvent(new RemovedEvent(volume, _container));
}
}
//we switched from Logical to physical. Add volume parameter if not available
else
{
if (volume != null)
{
return;
}
var parameterFactory = context.Resolve <IParameterFactory>();
volume = parameterFactory.CreateVolumeParameter();
_container.Add(volume);
context.Register(volume);
_volumeParameterCreatedHere = true;
context.PublishEvent(new AddedEvent <IParameter>(volume, _container));
}
}
public IContextMenu InitializeWith(IObjectBaseDTO dto, IPresenter presenter)
{
var simulation = dto.DowncastTo <SimulationViewItem>().Simulation;
//a simulation might not be registered yet which is required to execute some of the action
_context.Register(simulation);
_allMenuItems = new List <IMenuBarItem>
{
createEditItem(simulation),
createRenameItem(simulation),
createConfigure(simulation),
createRunItem(simulation),
createParameterIdentificationItem(simulation),
createSensitivityAnalysisItem(simulation),
createStartPopulationSimulation(simulation),
createSaveItem(simulation),
createReportItemFor(simulation),
createAddToJournal(simulation),
exportSimulationResultsToExcel(simulation),
createExportForMatlabItem(simulation),
createMatlabODEExportItem(simulation),
createDebugReportItem(simulation),
createExportModelPartsItem(simulation),
createImportReactionParameters(simulation),
createDeleteItem(simulation),
createDeleteAllResultsItem(simulation),
};
return(this);
}
private void addDefault <T>(string defaultName, Func <T> buildingBlockCreator) where T : IBuildingBlock
{
var project = _context.CurrentProject;
var buildingBlock = buildingBlockCreator().WithName(defaultName);
project.AddBuildingBlock(buildingBlock);
_context.Register(buildingBlock);
}
protected override void ExecuteWith(IMoBiContext context)
{
var project = context.CurrentProject;
context.Register(_simulation);
project.AddSimulation(_simulation);
context.PublishEvent(new SimulationAddedEvent(_simulation));
}
public void should_be_able_to_create_simulation()
{
_results.State.ShouldNotBeEqualTo(ValidationState.Invalid, _results.ValidationResult.Messages.SelectMany(x => x.Details).ToString("\n"));
_simulation = new MoBiSimulation {
BuildConfiguration = _buildConfiguration, Model = _results.Model
};
_simulation.Id = "Sim";
_context.Register(_simulation);
_simModelManager.RunSimulation(_simulation);
}
protected override void Context()
{
base.Context();
var simulationTransfer = LoadPKML <SimulationTransfer>("523_Export_S1");
_context = IoC.Resolve <IMoBiContext>();
_simulation = simulationTransfer.Simulation as IMoBiSimulation;
_context.Register(_simulation);
_context.Get <IFormula>(_simulation.Model.Root.GetAllChildren <IUsingFormula>(x => x.Formula.IsCachable()).FirstOrDefault().Formula.Id).ShouldNotBeNull();
}
protected override void ExecuteWith(IMoBiContext context)
{
var project = context.CurrentProject;
context.Register(_buildingBlock);
addToProject(project);
if (!Silent)
{
context.PublishEvent(new AddedEvent <T>(_buildingBlock, project));
}
}
protected override void ExecuteWith(IMoBiContext context)
{
base.ExecuteWith(context);
Description = AppConstants.Commands.AddToDescription(ObjectType, _itemToAdd.Name, _parent.Name, context.TypeFor(_buildingBlock), _buildingBlock.Name);
context.Register(_itemToAdd);
AddTo(_itemToAdd, _parent, context);
if (!Silent)
{
context.PublishEvent(new AddedEvent <TChild>(_itemToAdd, _parent));
}
}
public void should_update_object_registration()
{
A.CallTo(() => _context.Register(_simulation)).MustHaveHappened();
A.CallTo(() => _context.UnregisterSimulation(_simulation)).MustHaveHappened();
}
