protected override void Context()
{
base.Context();
_protocolToEdit = new SimpleProtocol();
A.CallTo(() => _protocolUpdater.ValidateSwitchFrom(_protocolToEdit)).Returns(false);
sut.Edit(_protocolToEdit);
}
public void Visit(SimpleProtocol protocol)
{
_metaData = new ProtocolMetaData {
ProtocolMode = ProtocolMode.Simple
};
serializeContentFor(protocol);
}
private void addSingularSchemaItemTo(Schema schema, SimpleProtocol simpleProtocol)
{
var availableTime = simpleProtocol.EndTimeParameter.Value - schema.StartTime.Value;
if (availableTime <= 0)
{
return;
}
schema.AddSchemaItem(createSchemaItem(0, simpleProtocol, schema));
if (simpleProtocol.DosingInterval.Id != DosingIntervalId.DI_6_6_12)
{
return;
}
if (availableTime <= 360)
{
return;
}
schema.AddSchemaItem(createSchemaItem(360, simpleProtocol, schema));
if (availableTime <= 720)
{
return;
}
schema.AddSchemaItem(createSchemaItem(720, simpleProtocol, schema));
}
void ReceiveCallback(IAsyncResult ar)
{
int bytesRead = 0;
try
{
bytesRead = m_socketClient.EndReceiveFrom(ar, ref m_remoteEP);
}
catch (ObjectDisposedException ex)
{
return;
}
catch (SocketException ex)
{
StartReceive();
return;
}
var packet = SimpleProtocol.Decode(m_buffer, bytesRead);
m_handler?.Invoke(packet, m_remoteEP as IPEndPoint);
/*
* if (p.Sequence <= in_sequence)
* {
* in_sequence = p.Sequence;
* if (OnIncomingPacket != null)
* OnIncomingPacket(p);
* }
*/
StartReceive();
}
public void Visit(SimpleProtocol simpleProtocol)
{
performCommonConversion(simpleProtocol);
var parameter = simpleProtocol.Parameter(ConverterConstants.Parameter.EndTime);
parameter.Name = Constants.Parameters.END_TIME;
}
public override void GlobalContext()
{
base.GlobalContext();
LoadProject("SimulationSettings_562");
_simulation = First <Simulation>();
_simulation2 = FindByName <Simulation>("S2");
_individual = First <Individual>();
_protocol = First <SimpleProtocol>();
}
protected override void Context()
{
base.Context();
_simpleProtocol = new SimpleProtocol();
_simpleProtocol.ApplicationType = ApplicationTypes.Intravenous;
_simpleProtocol.DosingInterval = DosingIntervals.DI_6_6_12;
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(CoreConstants.Parameters.INPUT_DOSE));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(3600).WithName(Constants.Parameters.END_TIME)); //2.5 day
}
protected override void Context()
{
_dosingInterval = DosingIntervals.DI_24;
_context = A.Fake <IExecutionContext>();
_protocol = new SimpleProtocol {
DosingInterval = DosingIntervals.DI_8_8_8
};
sut = new SetProtocolDosingIntervalCommand(_protocol, _dosingInterval, _context);
}
public SetProtocolDosingIntervalCommand(SimpleProtocol simpleProtocol, DosingInterval newDosingInterval, IExecutionContext context)
{
_simpleProtocol = simpleProtocol;
ObjectType = PKSimConstants.ObjectTypes.AdministrationProtocol;
CommandType = PKSimConstants.Command.CommandTypeEdit;
_newDosingInterval = newDosingInterval;
BuildingBlockId = simpleProtocol.Id;
context.UpdateBuildinBlockProperties(this, simpleProtocol);
}
private Task <SnapshotProtocol> createSnapshotFromSimpleProtocol(SimpleProtocol simpleProtocol)
{
return(SnapshotFrom(simpleProtocol, snapshot =>
{
snapshot.ApplicationType = simpleProtocol.ApplicationType.Name;
snapshot.DosingInterval = simpleProtocol.DosingInterval.Id;
snapshot.TargetOrgan = SnapshotValueFor(simpleProtocol.TargetOrgan);
snapshot.TargetCompartment = SnapshotValueFor(simpleProtocol.TargetCompartment);
}));
}
protected override void Context()
{
_simulation = new IndividualSimulation
{
Properties = new SimulationProperties(),
SimulationSettings = new SimulationSettings(),
ModelConfiguration = new ModelConfiguration()
};
_individual = new Individual().WithName("MyIndividual");
_speciesPopulation = new SpeciesPopulation();
_individual.OriginData = new OriginData {
SpeciesPopulation = _speciesPopulation
};
_compound = A.Fake <Compound>().WithName("MyCompound");
_protocol = A.Fake <SimpleProtocol>().WithName("MyProtocol");
_formulation = A.Fake <Formulation>().WithName("Formulation");
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Individual", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _individual
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Compound", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _compound
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Protocol", PKSimBuildingBlockType.Protocol)
{
BuildingBlock = _protocol
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("Formulation", PKSimBuildingBlockType.Formulation)
{
BuildingBlock = _formulation
});
_protocolToProtocolSchemaItemMapper = A.Fake <IProtocolToSchemaItemsMapper>();
sut = new SimulationConfigurationValidator(_protocolToProtocolSchemaItemMapper);
_speciesPopulation.IsHeightDependent = false;
_schemaItem = A.Fake <SchemaItem>();
_doseUnit = A.Fake <Unit>();
_schemaItem.Dose.DisplayUnit = _doseUnit;
_protocolProperties = new ProtocolProperties();
_formulationMapping = new FormulationMapping {
FormulationKey = "F1", Formulation = _formulation
};
_simulation.Properties.AddCompoundProperties(new CompoundProperties
{
Compound = _compound,
ProtocolProperties = _protocolProperties
});
A.CallTo(() => _protocolToProtocolSchemaItemMapper.MapFrom(_protocol)).Returns(new [] { _schemaItem });
}
public override void GlobalContext()
{
base.GlobalContext();
LoadProject("IsDefaultConversion_722");
_compound = First <Compound>();
_formulation = First <Formulation>();
_event = First <PKSimEvent>();
_simpleProtocol = First <SimpleProtocol>();
_advancedProtocol = First <AdvancedProtocol>();
_tubularSecretionProcess = _compound.AllProcesses().FirstOrDefault();
}
protected override void Context()
{
base.Context();
_simpleProtocol = new SimpleProtocol
{
ApplicationType = ApplicationTypes.Intravenous,
DosingInterval = DosingIntervals.Single
};
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(CoreConstants.Parameters.INPUT_DOSE));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(Constants.Parameters.END_TIME));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(3).WithName(Constants.Parameters.START_TIME));
}
public SimpleProtocolDTO MapFrom(SimpleProtocol simpleProtocol)
{
return(new SimpleProtocolDTO(simpleProtocol)
{
Dose = _parameterDTOMapper.MapFrom(simpleProtocol.Dose),
EndTime = _parameterDTOMapper.MapFrom(simpleProtocol.EndTimeParameter),
ApplicationType = simpleProtocol.ApplicationType,
DosingInterval = simpleProtocol.DosingInterval,
TargetOrgan = simpleProtocol.TargetOrgan,
TargetCompartment = simpleProtocol.TargetCompartment
});
}
public static bool ParameterShouldBeExported(this SimpleProtocol simpleProtocol, IParameter parameter)
{
if (!ParameterShouldBeExported((ISchemaItem)simpleProtocol, parameter))
{
return(false);
}
if (parameter.IsNamed(Constants.Parameters.END_TIME) && simpleProtocol.IsSingleDosing)
{
return(false);
}
return(true);
}
protected override void Context()
{
base.Context();
_doseParameterDTO = A.Fake <ParameterDTO>();
_endTimeParameterDTO = A.Fake <ParameterDTO>();
_simpleProtocol = new SimpleProtocol();
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameters.DOSE));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(Constants.Parameters.END_TIME));
_simpleProtocol.DosingInterval = DosingIntervals.DI_24;
_simpleProtocol.ApplicationType = ApplicationTypes.Oral;
A.CallTo(() => _parameterDTOMapper.MapFrom(_simpleProtocol.Dose)).Returns(_doseParameterDTO);
A.CallTo(() => _parameterDTOMapper.MapFrom(_simpleProtocol.EndTimeParameter)).Returns(_endTimeParameterDTO);
}
protected override void Context()
{
base.Context();
_newApplicationType = ApplicationTypes.UserDefined;
_simpleProtocol = new SimpleProtocol();
_para1 = A.Fake <IParameter>().WithName("toto");
_para2 = A.Fake <IParameter>().WithName("tat");
_setApplicationTypeCommand = A.Fake <IPKSimCommand>();
A.CallTo(() => _protocolTask.AllDynamicParametersFor(_simpleProtocol)).Returns(new[] { _para1, _para2 });
A.CallTo(() => _protocolTask.SetApplicationType(_simpleProtocol, _newApplicationType)).Returns(_setApplicationTypeCommand);
_simpleProtocol.ApplicationType = ApplicationTypes.UserDefined;
sut.EditProtocol(_simpleProtocol);
A.CallTo(() => _dynamicParameterPresenter.Edit(A <IEnumerable <IParameter> > ._))
.Invokes(x => _editedParameters = x.GetArgument <IEnumerable <IParameter> >(0));
}
public IEnumerable <Schema> MapFrom(SimpleProtocol simpleProtocol)
{
var container = new Container();
var schema = _schemaFactory.Create(container);
container.Add(schema);
if (simpleProtocol.DosingInterval == DosingIntervals.Single)
{
schema.NumberOfRepetitions.Value = 1;
schema.AddSchemaItem(createSchemaItem(simpleProtocol.StartTime.Value, simpleProtocol, schema));
return(container.GetChildren <Schema>());
}
var protocolDuration = simpleProtocol.EndTimeParameter.Value;
int numberOfRepetition = (int)Math.Floor(protocolDuration / simpleProtocol.DosingInterval.IntervalLength);
schema.NumberOfRepetitions.Value = numberOfRepetition;
addDosingIntevalSchemaItemTo(schema, simpleProtocol);
if (schema.Duration == protocolDuration)
{
return(container.GetChildren <Schema>());
}
//now we might need to add another schema if the time specified could not fit an entire repetition, or just add
//another repetition if the created schema has the same length as the default schema
var schemaSingular = _schemaFactory.Create(container);
schemaSingular.NumberOfRepetitions.Value = 1;
schemaSingular.StartTime.Value = schema.Duration;
addSingularSchemaItemTo(schemaSingular, simpleProtocol);
if (schemaSingular.SchemaItems.Any())
{
if (schema.SchemaItems.Count() != schemaSingular.SchemaItems.Count())
{
container.Add(schemaSingular);
}
else
{
schema.NumberOfRepetitions.Value++;
}
}
return(container.GetChildren <Schema>());
}
private SchemaItem createSchemaItem(double startTime, SimpleProtocol simpleProtocol, Schema schema)
{
var schemaItem = _schemaItemFactory.Create(simpleProtocol.ApplicationType, schema);
schemaItem.StartTime.Value = startTime;
schemaItem.StartTime.DisplayUnit = simpleProtocol.TimeUnit;
schemaItem.Dose.Value = simpleProtocol.Dose.Value;
schemaItem.Dose.DisplayUnit = simpleProtocol.DoseUnit;
schemaItem.TargetCompartment = simpleProtocol.TargetCompartment;
schemaItem.TargetOrgan = simpleProtocol.TargetOrgan;
foreach (var parameter in _schemaItemParameterRetriever.AllDynamicParametersFor(simpleProtocol))
{
schemaItem.Parameter(parameter.Name).Value = parameter.Value;
}
schemaItem.FormulationKey = simpleProtocol.FormulationKey;
return(schemaItem);
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_schemaMapper = A.Fake <SchemaMapper>();
_protocolFactory = A.Fake <IProtocolFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
sut = new ProtocolMapper(_parameterMapper, _protocolFactory, _schemaMapper, _dimensionRepository);
_simpleProtocol = new SimpleProtocol
{
ApplicationType = ApplicationTypes.Intravenous,
DosingInterval = DosingIntervals.DI_6_6_12,
Name = "Simple Protocol",
Description = "Simple Protocol description",
};
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(3).WithName(Constants.Parameters.START_TIME));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(4).WithName(CoreConstants.Parameters.INPUT_DOSE));
_simpleProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(Constants.Parameters.END_TIME));
A.CallTo(() => _parameterMapper.MapToSnapshot(_simpleProtocol.StartTime)).Returns(new Parameter().WithName(_simpleProtocol.StartTime.Name));
A.CallTo(() => _parameterMapper.MapToSnapshot(_simpleProtocol.Dose)).Returns(new Parameter().WithName(_simpleProtocol.Dose.Name));
A.CallTo(() => _parameterMapper.MapToSnapshot(_simpleProtocol.EndTimeParameter)).Returns(new Parameter().WithName(_simpleProtocol.EndTimeParameter.Name));
_advancedProtocol = new AdvancedProtocol
{
Name = "Advanced Protocol",
Description = "Advanced Protocol description",
TimeUnit = DomainHelperForSpecs.TimeDimensionForSpecs().DefaultUnit,
};
_schema = new Schema().WithName("Schema1");
_advancedProtocol.AddSchema(_schema);
_advancedProtocolParameter = DomainHelperForSpecs.ConstantParameterWithValue(3).WithName("AdvancedProtocolParameter");
_advancedProtocol.Add(_advancedProtocolParameter);
A.CallTo(() => _parameterMapper.MapToSnapshot(_advancedProtocolParameter)).Returns(new Parameter().WithName(_advancedProtocolParameter.Name));
_snapshotSchema = new Snapshots.Schema().WithName(_schema.Name);
A.CallTo(() => _schemaMapper.MapToSnapshot(_schema)).Returns(_snapshotSchema);
A.CallTo(() => _dimensionRepository.Time).Returns(DomainHelperForSpecs.TimeDimensionForSpecs());
return(Task.FromResult(true));
}
private void addDosingIntevalSchemaItemTo(Schema schema, SimpleProtocol simpleProtocol)
{
//always add a first interval
schema.AddSchemaItem(createSchemaItem(0, simpleProtocol, schema));
schema.TimeBetweenRepetitions.Value = simpleProtocol.DosingInterval.IntervalLength;
switch (simpleProtocol.DosingInterval.Id)
{
case DosingIntervalId.DI_6_6_12:
schema.AddSchemaItem(createSchemaItem(360, simpleProtocol, schema));
schema.AddSchemaItem(createSchemaItem(720, simpleProtocol, schema));
break;
case DosingIntervalId.DI_6_6_6_6:
case DosingIntervalId.DI_8_8_8:
case DosingIntervalId.DI_12_12:
case DosingIntervalId.DI_24:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override void Context()
{
base.Context();
_sourceProtocol = new SimpleProtocol {
Id = "Id", Name = "Simple Protocol", Description = "tralala"
};
_sourceProtocol.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("SimpleParameter"));
_targetProtocol = new AdvancedProtocol {
DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(name: "AdvancedParameter")
};
_schema1 = new Schema {
Name = "Schema1"
};
_schema2 = new Schema {
Name = "Schema2"
};
_oldSchema = new Schema {
Name = "_oldSchema"
};
_targetProtocol.AddSchema(_oldSchema);
A.CallTo(() => _schemaMapper.MapFrom(_sourceProtocol)).Returns(new[] { _schema1, _schema2 });
}
public IndividualSimulation RunForBioavailability(SimpleProtocol simpleIvProtocol, IndividualSimulation individualSimulation, Compound compound)
{
return(createAndRun(x => x.CreateForBioAvailability(simpleIvProtocol, compound, individualSimulation)));
}
public IPKSimCommand SetDosingInterval(SimpleProtocol protocol, DosingInterval newDosingInterval)
{
return(new SetProtocolDosingIntervalCommand(protocol, newDosingInterval, _executionContext).Run(_executionContext));
}
protected override void Context()
{
_simulation = First <Simulation>();
_protocol = First <SimpleProtocol>();
_compound = First <Compound>();
}
public void Visit(SimpleProtocol simpleProtocol)
{
convertSchemaItem(simpleProtocol);
_converted = true;
}
public override void RestoreExecutionData(IExecutionContext context)
{
base.RestoreExecutionData(context);
_simpleProtocol = context.Get <SimpleProtocol>(BuildingBlockId);
}
protected override void Context()
{
_vssCalculator = A.Fake <IVSSCalculator>();
_parameterFactory = A.Fake <IParameterFactory>();
_protocolMapper = A.Fake <IProtocolToSchemaItemsMapper>();
_protocolFactory = A.Fake <IProtocolFactory>();
_globalPKAnalysisRunner = A.Fake <IGlobalPKAnalysisRunner>();
_pkCalculationOptionsFactory = A.Fake <IPKCalculationOptionsFactory>();
_pkAnalysisTask = A.Fake <IPKAnalysesTask>();
_interactionTask = A.Fake <IInteractionTask>();
_cloner = A.Fake <ICloner>();
sut = new GlobalPKAnalysisTask(_parameterFactory, _protocolMapper, _protocolFactory, _globalPKAnalysisRunner,
_pkAnalysisTask, _pkCalculationOptionsFactory, _vssCalculator, _interactionTask, _cloner);
var baseGrid = new BaseGrid("time", A.Fake <IDimension>());
_peripheralVenousBloodPlasma = CalculationColumnFor(baseGrid, CoreConstants.Organ.PeripheralVenousBlood, CoreConstants.Observer.PLASMA_PERIPHERAL_VENOUS_BLOOD, CoreConstants.Observer.PLASMA_PERIPHERAL_VENOUS_BLOOD, _compoundName);
_venousBloodPlasma = CalculationColumnFor(baseGrid, CoreConstants.Organ.VenousBlood, CoreConstants.Compartment.Plasma, CoreConstants.Observer.CONCENTRATION_IN_CONTAINER, _compoundName);
_individual = A.Fake <Individual>();
_species = new Species();
A.CallTo(() => _individual.Species).Returns(_species);
_compound = new Compound().WithName(_compoundName);
_compoundProperties = new CompoundProperties {
Compound = _compound
};
_simulationSchemaItems = new List <SchemaItem>();
_protocol = new SimpleProtocol();
_compoundProperties.ProtocolProperties.Protocol = _protocol;
A.CallTo(() => _protocolMapper.MapFrom(_protocol)).Returns(_simulationSchemaItems);
_simulation = new IndividualSimulation {
Properties = new SimulationProperties()
};
_simulation.Properties.AddCompoundProperties(_compoundProperties);
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("CompId", PKSimBuildingBlockType.Compound)
{
BuildingBlock = _compound
});
_simulation.AddUsedBuildingBlock(new UsedBuildingBlock("IndividualId", PKSimBuildingBlockType.Individual)
{
BuildingBlock = _individual
});
_simulation.DataRepository = new DataRepository {
_venousBloodPlasma, _peripheralVenousBloodPlasma
};
_venousBloodPK = new PKValues();
_venousBloodPK.AddValue(Constants.PKParameters.Vss, 10);
_venousBloodPK.AddValue(Constants.PKParameters.Vd, 11);
_venousBloodPK.AddValue(Constants.PKParameters.CL, 12);
_venousBloodPK.AddValue(Constants.PKParameters.AUC_inf, 13);
_venousBloodPK.AddValue(Constants.PKParameters.AUC_inf_tD1_norm, 14);
_peripheralVenousBloodPK = new PKValues();
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.Vss, 21);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.Vd, 22);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.CL, 23);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.AUC_inf, 24);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.AUC_inf_tD1_norm, 25);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.C_max, 26);
_peripheralVenousBloodPK.AddValue(Constants.PKParameters.C_max_tDLast_tDEnd, 27);
A.CallTo(() => _pkAnalysisTask.CalculatePK(_venousBloodPlasma, A <PKCalculationOptions> ._)).Returns(_venousBloodPK);
A.CallTo(() => _pkAnalysisTask.CalculatePK(_peripheralVenousBloodPlasma, A <PKCalculationOptions> ._)).Returns(_peripheralVenousBloodPK);
A.CallTo(() => _parameterFactory.CreateFor(A <string> ._, A <double> ._, A <string> ._, PKSimBuildingBlockType.Simulation))
.ReturnsLazily(s => new PKSimParameter().WithName((string)s.Arguments[0])
.WithDimension(A.Fake <IDimension>())
.WithFormula(new ConstantFormula((double)s.Arguments[1])));
}
public override void EditProtocol(Protocol protocol)
{
_protocol = protocol.DowncastTo <SimpleProtocol>();
_view.BindTo(_simpleProtocolDTOMapper.MapFrom(_protocol));
bindToDynamicParameters();
}
protected override void ClearReferences()
{
_simpleProtocol = null;
}
