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);
}
