protected override void Context() { base.Context(); _simulationOutput = A.Fake <OutputSchema>(); _simulatinIntervalToRemove = A.Fake <OutputInterval>(); A.CallTo(() => _simulationOutput.Intervals).Returns(new[] { _simulatinIntervalToRemove }); }
protected override Task Context() { _parameterMapper = A.Fake <ParameterMapper>(); _outputIntervalFactory = A.Fake <IOutputIntervalFactory>(); sut = new OutputIntervalMapper(_parameterMapper, _outputIntervalFactory); _outputInterval = new OutputInterval { Name = "Interval" }; _endTimeParameter = DomainHelperForSpecs.ConstantParameterWithValue(1, isDefault: true).WithName(Constants.Parameters.END_TIME); _resolutionParameter = DomainHelperForSpecs.ConstantParameterWithValue(1, isDefault: true).WithName(Constants.Parameters.RESOLUTION); _anotherParameter = DomainHelperForSpecs.ConstantParameterWithValue(1, isDefault: false).WithName("Another"); _outputInterval.Add(_endTimeParameter); _outputInterval.Add(_anotherParameter); _outputInterval.Add(_resolutionParameter); _endTimeSnapshotParameter = new Parameter().WithName(_endTimeParameter.Name); _anotherSnapshotParameter = new Parameter().WithName(_anotherParameter.Name); _resolutionSnapshotParameter = new Parameter().WithName(_resolutionParameter.Name); A.CallTo(() => _parameterMapper.MapToSnapshot(_endTimeParameter)).Returns(_endTimeSnapshotParameter); A.CallTo(() => _parameterMapper.MapToSnapshot(_anotherParameter)).Returns(_anotherSnapshotParameter); A.CallTo(() => _parameterMapper.MapToSnapshot(_resolutionParameter)).Returns(_resolutionSnapshotParameter); return(_completed); }
private OutputSchema createWith(OutputInterval interval) { var outputSchema = _objectBaseFactory.Create <OutputSchema>(); outputSchema.AddInterval(interval); return(outputSchema); }
protected OutputIntervalInSimulationCommand(OutputSchema schema, OutputInterval interval, IMoBiSimulation simulation) : base(simulation.OutputSchema, simulation) { _schema = schema; _interval = interval; ObjectType = ObjectTypes.SimulationSettings; }
private IMoBiCommand getAddCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings, IMoBiSimulation simulation) { if (simulation == null) { return(new AddOutputIntervalCommand(schema, interval, simulationSettings)); } return(new AddOutputIntervalInSimulationCommand(schema, interval, simulation)); }
private IMoBiCommand getRemoveCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings, IMoBiSimulation simulation) { if (simulation == null) { return(new RemoveOutputIntervalCommand(schema, interval, simulationSettings)); } return(new RemoveOutputIntervalFromSimulationCommand(schema, interval, simulation)); }
public ICommand RemoveSimulationIntervalFrom(OutputInterval simulationInterval, OutputSchema simulationOutput) { if (simulationOutput.Intervals.Count() <= 1) { throw new CannotDeleteSimulationIntervalException(); } return(new RemoveSimulationIntervalFromSimulationOutputCommand(simulationInterval, simulationOutput, _executionContext).Run(_executionContext)); }
protected override void Context() { base.Context(); _simulationOutput = A.Fake <OutputSchema>(); _defaultInterval = A.Fake <OutputInterval>().WithName("oldName"); _newName = "Tralala"; A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval); A.CallTo(() => _containerTask.CreateUniqueName(_simulationOutput, _defaultInterval.Name, false)).Returns(_newName); }
private static OutputIntervalExport outputIntervalExportFrom(OutputInterval outputInterval) { return(new OutputIntervalExport { StartTime = outputInterval.StartTime.Value, EndTime = outputInterval.EndTime.Value, Resolution = outputInterval.Resolution.Value }); }
protected override void Context() { base.Context(); _newName = "Tralala"; _outputSchema = new OutputSchema(); _defaultInterval = new OutputInterval().WithName("oldName"); A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval); A.CallTo(() => _containerTask.CreateUniqueName(_outputSchema, _defaultInterval.Name, false)).Returns(_newName); }
protected override void Context() { _outputSchema = new OutputSchema(); _defaultInterval = new OutputInterval(); _objectBaseFactory = A.Fake <IObjectBaseFactory>(); _outputIntervalFactory = A.Fake <IOutputIntervalFactory>(); A.CallTo(() => _objectBaseFactory.Create <OutputSchema>()).Returns(_outputSchema); A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval); sut = new OutputSchemaFactory(_objectBaseFactory, _outputIntervalFactory); }
protected override void Context() { base.Context(); _simulationInterval = A.Fake <OutputInterval>(); A.CallTo(() => _simulationInterval.StartTime).Returns(A.Fake <IParameter>()); A.CallTo(() => _simulationInterval.EndTime).Returns(A.Fake <IParameter>()); A.CallTo(() => _simulationInterval.Resolution).Returns(A.Fake <IParameter>()); A.CallTo(_parameterDTOMapper).WithReturnType <ParameterDTO>().Returns(A.Fake <ParameterDTO>()); _result = sut.MapFrom(_simulationInterval); }
public OutputIntervalDTO MapFrom(OutputInterval outputInterval) { var outputIntervalDTO = new OutputIntervalDTO { OutputInterval = outputInterval }; outputIntervalDTO.StartTimeParameter = MapFrom(outputInterval.StartTime, outputIntervalDTO, x => x.StartTime, x => x.StartTimeParameter); outputIntervalDTO.EndTimeParameter = MapFrom(outputInterval.EndTime, outputIntervalDTO, x => x.EndTime, x => x.EndTimeParameter); outputIntervalDTO.ResolutionParameter = MapFrom(outputInterval.Resolution, outputIntervalDTO, x => x.Resolution, x => x.ResolutionParameter); return(outputIntervalDTO); }
protected override void Context() { base.Context(); _removeCommand = A.Fake <IPKSimCommand>(); _oneIntervalDTO = new OutputIntervalDTO(); _oneInterval = A.Fake <OutputInterval>(); _oneIntervalDTO.OutputInterval = _oneInterval; A.CallTo(() => _simulationSettingsTask.RemoveSimulationIntervalFrom(_oneInterval, _outputSchema)).Returns(_removeCommand); A.CallTo(() => _outputIntervalToOutputIntervalDTOMapper.MapFrom(_oneInterval)).Returns(_oneIntervalDTO); _allIntervals.Add(_oneInterval); sut.EditSettingsFor(_simulationToEdit); }
protected override async Task Context() { await base.Context(); var outputSchema = new OutputSchema(); _newInterval = new OutputInterval().WithName("Interval"); A.CallTo(() => _outputSchemaFactory.CreateEmpty()).Returns(outputSchema); A.CallTo(() => _outputIntervalMapper.MapToModel(_snapshotInterval)).Returns(_newInterval); _snapshot = await sut.MapToSnapshot(_outputSchema); A.CallTo(() => _containerTask.CreateUniqueName(outputSchema, _newInterval.Name, false)).Returns(_newName); }
public ICommand RemoveOuputInterval(OutputInterval outputInterval, ISimulationSettings simulationSettings, IMoBiSimulation simulation) { var schema = simulationSettings.OutputSchema; if (schema.Intervals.Count() > 1) { return(getRemoveCommand(schema, outputInterval, simulationSettings, simulation).Run(_context)); } else { throw new MoBiException(AppConstants.Exceptions.CanNotRemoveLastItem); } }
protected override async Task Context() { await base.Context(); _snapshot = await sut.MapToSnapshot(_outputInterval); _intervalParameter = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P1"); var interval = new OutputInterval { _intervalParameter }; A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(interval); }
protected override void Context() { base.Context(); _parameter = new Parameter { IsDefault = false }; _interval = new OutputInterval { _parameter }; _simulationSettings = new SimulationSettings { OutputSchema = new OutputSchema() }; _simulationSettings.OutputSchema.AddInterval(_interval); }
protected override Task Context() { _outputIntervalMapper = A.Fake <OutputIntervalMapper>(); _outputSchemaFactory = A.Fake <IOutputSchemaFactory>(); _containerTask = A.Fake <IContainerTask>(); sut = new OutputSchemaMapper(_outputIntervalMapper, _outputSchemaFactory, _containerTask); _outputSchema = new OutputSchema(); _outputInterval = new OutputInterval().WithName("Interval"); _outputSchema.AddInterval(_outputInterval); _snapshotInterval = new Snapshots.OutputInterval(); A.CallTo(() => _outputIntervalMapper.MapToSnapshot(_outputInterval)).Returns(_snapshotInterval); return(_completed); }
static void Callback(TimePointStreamingEmitter emitter, OutputInterval interval, TimePoint deadline, object user_obj) { foreach (var tpoint in interval) { // For each control point available at this time point... for (int i = 0; i < tpoint.count(); ++i) { // Set the relevant data for this control point var point = tpoint.persistentControlPoint(i); point.setPosition(_positions[_current]); point.setIntensity(_intensities[_current]); point.enable(); } // Increment the counter so that we get the next "step" next time _current = (_current + 1) % (uint)_positions.Length; } }
private readonly double _offsetInMinutes = 1440; //1 days in minutes protected override void Context() { base.Context(); _simulation = A.Fake <Simulation>(); _protocol = A.Fake <Protocol>(); _simulation.SimulationSettings = null; _currentEndTimeInHours = 50; _currentEndTimeInMinutes = _currentEndTimeInHours * 60; _highResolutionInterval = A.Fake <OutputInterval>(); _lowResolutionInterval = A.Fake <OutputInterval>(); A.CallTo(() => _objectBaseFactory.Create <OutputSchema>()).Returns(new OutputSchema()); A.CallTo(() => _outputIntervalFactory.Create(0, CoreConstants.HIGH_RESOLUTION_END_TIME_IN_MIN, CoreConstants.HIGH_RESOLUTION_IN_PTS_PER_MIN)).Returns(_highResolutionInterval); A.CallTo(() => _outputIntervalFactory.Create(CoreConstants.HIGH_RESOLUTION_END_TIME_IN_MIN, _currentEndTimeInMinutes + _offsetInMinutes, CoreConstants.LOW_RESOLUTION_IN_PTS_PER_MIN)).Returns(_lowResolutionInterval); A.CallTo(() => _protocol.EndTime).Returns(_currentEndTimeInMinutes); A.CallTo(() => _simulation.AllBuildingBlocks <Protocol>()).Returns(new[] { _protocol }); }
protected override void Context() { base.Context(); _defaultInterval = new OutputInterval(); A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval); _time = A.Fake <IDimension>(); A.CallTo(() => _time.Name).Returns(Constants.Dimension.TIME); _resolution = A.Fake <IDimension>(); A.CallTo(() => _resolution.Name).Returns(Constants.Dimension.RESOLUTION); _startTimeParameter = new PKSimParameter().WithName(Constants.Parameters.START_TIME).WithDimension(_time); _endTimeParameter = new PKSimParameter().WithName(Constants.Parameters.END_TIME).WithDimension(_time); _numberOfTimePointParameter = new PKSimParameter().WithName(Constants.Parameters.RESOLUTION).WithDimension(_resolution); _defaultInterval.Add(_startTimeParameter); _defaultInterval.Add(_endTimeParameter); _defaultInterval.Add(_numberOfTimePointParameter); }
// This callback is called every time the device is ready to accept new control point information private static void Callback(TimePointStreamingEmitter emitter, OutputInterval interval, TimePoint deadline, object userObj) { // For each time point in this interval... foreach (TimePointOnOutputInterval tPoint in interval) { if (_firstTime) { _startTime = tPoint.seconds(); _firstTime = false; } double t = tPoint.seconds() - _startTime; for (int i = 0; i < Circles.Length; i++) { Vector3 pos = Circles[i].EvaluateAt(t); tPoint.persistentControlPoint(i).setPosition(pos); tPoint.persistentControlPoint(i).setIntensity(Circles[i].Intensity); } } }
public void TestSerialization() { var schema = new OutputSchema(); var interval = new OutputInterval(); var quantitySelection = new OutputSelections(); var solverSettingsFactory = IoC.Resolve <ISolverSettingsFactory>(); var x1 = new SimulationSettings { Solver = solverSettingsFactory.CreateCVODE(), OutputSchema = schema, OutputSelections = quantitySelection }; interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.START_TIME).WithFormula(new ConstantFormula(0))); interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.END_TIME).WithFormula(new ConstantFormula(1440))); interval.Add(CreateObject <Parameter>().WithName(Constants.Parameters.RESOLUTION).WithFormula(new ConstantFormula(240))); quantitySelection.AddOutput(new QuantitySelection("A|B|C", QuantityType.Protein)); quantitySelection.AddOutput(new QuantitySelection("A|B", QuantityType.Enzyme)); var x2 = SerializeAndDeserialize(x1); AssertForSpecs.AreEqualSimulationSettings(x2, x1); }
protected override void Because() { _interval = sut.Create(0, 10, 5); }
public RemoveOutputIntervalCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(schema, interval, simulationSettings) { CommandType = AppConstants.Commands.DeleteCommand; Description = AppConstants.Commands.RemoveOutputIntervalFrom(simulationSettings.Name); }
public AddOutputIntervalCommand(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(schema, interval, simulationSettings) { CommandType = AppConstants.Commands.AddCommand; Description = AppConstants.Commands.AddOutputIntervalTo(simulationSettings.Name); }
protected OutputIntervalCommandBase(OutputSchema schema, OutputInterval interval, ISimulationSettings simulationSettings) : base(simulationSettings) { _schema = schema; _interval = interval; ObjectType = ObjectTypes.SimulationSettings; }
protected override void ClearReferences() { base.ClearReferences(); _schema = null; _interval = null; }
protected override async Task Because() { _newInteval = await sut.MapToModel(_snapshot); }