private void updateTransporterContainerFromTemplate(TransporterExpressionContainer expressionContainer,
TransporterContainerTemplate transporterContainerTemplate, TransportType defaultTransportType)
{
var transportType = transporterContainerTemplate?.TransportType ?? defaultTransportType;
expressionContainer.TransportDirection = TransportDirections.DefaultDirectionFor(transportType, expressionContainer);
}
public MembraneLocation MembraneLocationToUse(TransporterExpressionContainer transporterContainer, TransportType newTransportType)
{
if (!transporterContainer.HasPolarizedMembrane)
{
return(transporterContainer.MembraneLocation);
}
//Brain always plasma
if (transporterContainer.IsNamed(CoreConstants.Organ.Brain))
{
return(MembraneLocation.BloodBrainBarrier);
}
//intestine always apical
if (transporterContainer.GroupName == CoreConstants.Groups.GI_MUCOSA)
{
return(MembraneLocation.Apical);
}
//pgp and efflux always apical
if (newTransportType == TransportType.PgpLike || newTransportType == TransportType.Efflux)
{
return(MembraneLocation.Apical);
}
//not brain and intestine=>Influx is always basolateral
if (newTransportType == TransportType.Influx)
{
return(MembraneLocation.Basolateral);
}
return(transporterContainer.MembraneLocation);
}
protected override void Context()
{
base.Context();
_transporter = new IndividualTransporter {
TransportType = TransportType.Efflux, Name = "toto"
};
_transporterWithTemplate = new TransporterExpressionContainer {
MembraneLocation = MembraneLocation.Apical
}.WithName(_liver);
_transporterWithoutTemplate = new TransporterExpressionContainer {
MembraneLocation = MembraneLocation.Basolateral
}.WithName("Kidney");
_transporter.Add(_transporterWithTemplate);
_transporter.Add(_transporterWithoutTemplate);
_transporterContainerTemplate = new TransporterContainerTemplate {
MembraneLocation = MembraneLocation.Apical, TransportType = TransportType.Influx
};
_defaultTemplate = new TransporterContainerTemplate {
MembraneLocation = MembraneLocation.Basolateral, TransportType = TransportType.Influx
};
_allTransporterTemplates.Add(_transporterContainerTemplate);
A.CallTo(() => _repository.HasTransporterTemplateFor(_species, _transporter.Name)).Returns(true);
A.CallTo(() => _repository.TransportTypeFor(_species, _transporter.Name)).Returns(TransportType.Influx);
A.CallTo(() => _repository.TransportersFor(_species, _liver, _transporter.Name)).Returns(_allTransporterTemplates);
A.CallTo(() => _repository.TransportersFor(_species, _kidney, _transporter.Name)).Returns(new List <TransporterContainerTemplate>());
A.CallTo(() => _repository.TransportersFor(_species, _kidney)).Returns(new List <TransporterContainerTemplate> {
_defaultTemplate
});
}
private void updateFractionExpressedApical(TransporterExpressionContainer transporterContainer, TransportType transportType)
{
if (!transportType.IsOneOf(TransportType.Efflux, TransportType.Influx, TransportType.PgpLike))
{
return;
}
var fractionExpressedApical = transporterContainer.Parameter(CoreConstants.Parameters.FRACTION_EXPRESSED_APICAL);
if (fractionExpressedApical == null)
{
return;
}
//Parameter is a hidden parameter. This is used for consistency purpose only and should not be updated
if (!fractionExpressedApical.Visible)
{
return;
}
//value was set by the user.
if (fractionExpressedApical.Value != 0 && fractionExpressedApical.Value != 1)
{
return;
}
//Set the value according to the new transport type (Efflux + pgp one, Influx 0) except in mucosa where it is always apical
fractionExpressedApical.Value = transporterContainer.IsInMucosa() ? 1 : transportType == TransportType.Influx ? 0 : 1;
}
protected override void Context()
{
base.Context();
_transporterContainer = new TransporterExpressionContainer().WithName(_liver);
_species = "human";
A.CallTo(() => _repository.TransportersFor(_species, _liver)).Returns(_allTransporters);
_membrane = MembraneLocation.Apical;
_transportType = TransportType.Efflux;
_transporterContainerTemplate = new TransporterContainerTemplate {
MembraneLocation = _membrane, TransportType = _transportType
};
_allTransporters.Add(_transporterContainerTemplate);
}
public SetMembraneTypeCommand(TransporterExpressionContainer transporterContainer, TransportType transportType, MembraneLocation newMembraneLocation, IExecutionContext context)
{
_transporterContainer = transporterContainer;
_transportType = transportType;
_transporterContainerId = _transporterContainer.Id;
_newMembraneLocation = newMembraneLocation;
_individual = context.BuildingBlockContaining(_transporterContainer).DowncastTo <Individual>();
BuildingBlockId = _individual.Id;
_oldMembraneLocation = _transporterContainer.MembraneLocation;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildinBlockPropertiesInCommand(this, _individual);
}
public SetTransportDirectionCommand(TransporterExpressionContainer transporterContainer, TransportDirectionId newTransportDirection,
IExecutionContext context)
{
_transporterContainer = transporterContainer;
_newTransportDirection = newTransportDirection;
_transporterContainerId = _transporterContainer.Id;
_expressionProfile = context.BuildingBlockContaining(_transporterContainer).DowncastTo <ExpressionProfile>();
BuildingBlockId = _expressionProfile.Id;
_oldTransportDirection = _transporterContainer.TransportDirection;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildingBlockPropertiesInCommand(this, _expressionProfile);
}
protected override void Context()
{
sut = new IndividualTransporter().WithName("T");
_transpoterExpressionLiver = new TransporterExpressionContainer().WithName("Liver");
_transpoterExpressionLiver.AddProcessName("P1");
_transpoterExpressionKidney = new TransporterExpressionContainer().WithName("Kidney");
_transpoterExpressionKidney.AddProcessName("P2");
_transpoterExpressionBrain = new TransporterExpressionContainer().WithName("Brain");
_transpoterExpressionBrain.AddProcessName("P1");
sut.Add(_transpoterExpressionLiver);
sut.Add(_transpoterExpressionKidney);
sut.Add(_transpoterExpressionBrain);
}
public SetTransportTypeCommand(TransporterExpressionContainer transporterContainer, TransportType oldTransportType, TransportType newTransportType, MembraneLocation membraneLocationToUse, IExecutionContext context)
{
_transporterContainer = transporterContainer;
_membraneLocationToUse = membraneLocationToUse;
_transporterContainerId = _transporterContainer.Id;
_individual = context.BuildingBlockContaining(transporterContainer).DowncastTo <Individual>();
BuildingBlockId = _individual.Id;
_newTransportType = newTransportType;
_oldTransportType = oldTransportType;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildinBlockPropertiesInCommand(this, _individual);
Visible = false;
}
private TransportDirectionId retrieveTransporterDirectionFor(TransporterExpressionContainer transporterExpressionContainer, IParameter parameter,
bool isInOrganWithLumenOrBrain = false)
{
if (parameter.IsNamed(INITIAL_CONCENTRATION))
{
return(TransportDirectionId.None);
}
//Organ without lumen only show transporter direction at the rel exp parameter level
if (!isInOrganWithLumenOrBrain)
{
return(parameter.IsNamed(REL_EXP) ? transporterExpressionContainer.TransportDirection : TransportDirectionId.None);
}
return(!parameter.IsNamed(REL_EXP) ? transporterExpressionContainer.TransportDirection : TransportDirectionId.None);
}
public void UpdateTransporterFromTemplate(TransporterExpressionContainer transporterContainer, string species, MembraneLocation membraneLocation, TransportType transportType)
{
//we need to retrieve the process name for the given MembraneTupe/Process Type combo
var templateToUse = _transporterContainerTemplateRepository.TransportersFor(species, transporterContainer.Name)
.Where(x => x.MembraneLocation == membraneLocation)
.FirstOrDefault(x => x.TransportType == transportType);
//That should never happen, otherwise we would have a transporter container with an unknown process
if (templateToUse == null)
{
throw new PKSimException(PKSimConstants.Error.CouldNotFindTransporterFor(transporterContainer.Name, membraneLocation.ToString(), transportType.ToString()));
}
transporterContainer.UpdatePropertiesFrom(templateToUse);
}
protected override void Context()
{
base.Context();
_transporter = new IndividualTransporter().WithName("TRANS");
_simulationSubject = A.Fake <ISimulationSubject>();
_simulationSubject.Species.Name = "Human";
var liver = new Container().WithName(CoreConstants.Organ.LIVER);
var liverCell = new Container().WithName(CoreConstants.Compartment.INTRACELLULAR).WithParentContainer(liver);
_transporterExpressionContainer = new TransporterExpressionContainer().WithParentContainer(liverCell);
_expressionParameter = DomainHelperForSpecs.ConstantParameterWithValue(0.5).WithName(CoreConstants.Parameters.REL_EXP);
_transporterExpressionContainer.Add(_expressionParameter);
_expressionParameterDTO = new TransporterExpressionParameterDTO();
A.CallTo(() => _expressionParameterMapper.MapFrom(_expressionParameter)).Returns(_expressionParameterDTO);
A.CallTo(() => _transporterContainerTemplateRepository.HasTransporterTemplateFor(_simulationSubject.Species.Name, _transporter.Name)).Returns(true);
A.CallTo(() => _simulationSubject.AllMoleculeContainersFor <TransporterExpressionContainer>(_transporter)).Returns(new[] { _transporterExpressionContainer });
}
protected override void Context()
{
_mucosa = new Container().WithName(MUCOSA);
_brain_cell = create(BRAIN, INTRACELLULAR);
_brain_pls = create(BRAIN, PLASMA);
_liver_cell = create(PERICENTRAL, INTRACELLULAR, LIVER);
_liver_int = create(PERICENTRAL, INTERSTITIAL, LIVER);
_bone_cell = create(BONE, INTRACELLULAR);
_kidney_cell = create(KIDNEY, INTRACELLULAR);
_kidney_int = create(KIDNEY, INTERSTITIAL);
_mucosaDuodenumCell = create(DUODENUM, INTRACELLULAR, MUCOSA);
_mucosaDuodenumInt = create(DUODENUM, INTERSTITIAL, MUCOSA);
_transporterExpressionContainer = new TransporterExpressionContainer
{
TransportDirection = TransportDirectionId.InfluxInterstitialToIntracellular
};
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_logger = A.Fake <IOSPSuiteLogger>();
sut = new ExpressionContainerMapper(_parameterMapper, _logger);
_relativeExpressionParameter =
DomainHelperForSpecs.ConstantParameterWithValue(0, isDefault: true).WithName(CoreConstants.Parameters.REL_EXP);
_moleculeExpressionContainer = new MoleculeExpressionContainer().WithName("EXP");
_moleculeExpressionContainer.Add(_relativeExpressionParameter);
_transporterRelativeExpressionParameter =
DomainHelperForSpecs.ConstantParameterWithValue(0, isDefault: true).WithName(CoreConstants.Parameters.REL_EXP);
_transporterExpressionContainer = new TransporterExpressionContainer().WithName("TRANS");
_transporterExpressionContainer.TransportDirection = TransportDirectionId.InfluxInterstitialToIntracellular;
_bloodCellsExpressionContainer = new TransporterExpressionContainer().WithName(CoreConstants.Compartment.BLOOD_CELLS);
_bloodCellsExpressionContainer.TransportDirection = TransportDirectionId.BiDirectionalBloodCellsPlasma;
_transporterExpressionContainer.Add(_transporterRelativeExpressionParameter);
_individual = new Individual {
OriginData = new OriginData {
Species = new Species().WithName("Human")
}
};
_expressionContainerMapperContext = new ExpressionContainerMapperContext(new SnapshotContext())
{
};
_enzyme = new IndividualEnzyme {
_moleculeExpressionContainer
};
_transporter = new IndividualTransporter {
_transporterExpressionContainer, _bloodCellsExpressionContainer
};
return(_completed);
}
private void convertTransportContainer(TransporterExpressionContainer expressionContainerToConvert, IReadOnlyList <TransporterExpressionContainer> allTransporterExpressionContainers)
{
//This should never happen as a tag was added in the xml conversion with the membrane location
if (!expressionContainerToConvert.Tags.Any())
{
return;
}
var membraneLocation = EnumHelper.ParseValue <MembraneLocation>(expressionContainerToConvert.Tags.ElementAt(0).Value);
var matchingContainers = allTransporterExpressionContainers
.Where(x => x.LogicalContainerName == expressionContainerToConvert.Name || x.CompartmentName == expressionContainerToConvert.Name)
.ToList();
//only one direction to take into consideration. all good, nothing else to do
if (matchingContainers.Count == 1)
{
return;
}
MembraneLocationConverter.ConvertMembraneLocationToParameterFraction(matchingContainers, membraneLocation);
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_transportContainerUpdater = A.Fake <ITransportContainerUpdater>();
_logger = A.Fake <ILogger>();
sut = new ExpressionContainerMapper(_parameterMapper, _transportContainerUpdater, _logger);
_relativeExpressionParameter = DomainHelperForSpecs.ConstantParameterWithValue(0, isDefault: true).WithName(CoreConstants.Parameters.REL_EXP);
_moleculeExpressionContainer = new MoleculeExpressionContainer().WithName("EXP");
_moleculeExpressionContainer.Add(_relativeExpressionParameter);
_transporterRelativeExpressionParameter = DomainHelperForSpecs.ConstantParameterWithValue(0, isDefault: true).WithName(CoreConstants.Parameters.REL_EXP);
_transporterExpressionContainer = new TransporterExpressionContainer().WithName("TRANS");
_transporterExpressionContainer.MembraneLocation = MembraneLocation.Apical;
_transporterExpressionContainer.Add(_transporterRelativeExpressionParameter);
_individual = new Individual {
OriginData = new Model.OriginData {
Species = new Species().WithName("Human")
}
};
_expressionContainerMapperContext = new ExpressionContainerMapperContext
{
SimulationSubject = _individual
};
_enzyme = new IndividualEnzyme {
_moleculeExpressionContainer
};
_transporter = new IndividualTransporter {
_transporterExpressionContainer
};
return(_completed);
}
public override void RestoreExecutionData(IExecutionContext context)
{
base.RestoreExecutionData(context);
_individual = context.Get <Individual>(BuildingBlockId);
_transporterContainer = context.Get <TransporterExpressionContainer>(_transporterContainerId);
}
private void mapTransporterExpressionProperties(ExpressionContainer snapshot, TransporterExpressionContainer transporterExpressionContainer)
{
if (transporterExpressionContainer == null)
{
return;
}
snapshot.MembraneLocation = transporterExpressionContainer.MembraneLocation;
}
protected override void ClearReferences()
{
_transporterContainer = null;
_expressionProfile = null;
}
protected override void ClearReferences()
{
_transporterContainer = null;
_individual = null;
}
public override void RestoreExecutionData(IExecutionContext context)
{
base.RestoreExecutionData(context);
_expressionProfile = context.Get <ExpressionProfile>(BuildingBlockId);
_transporterContainer = context.Get <TransporterExpressionContainer>(_transporterContainerId);
}
public ICommand SetTransportDirection(TransporterExpressionContainer transporterContainer, TransportDirectionId transportDirection)
{
return(new SetTransportDirectionCommand(transporterContainer, transportDirection, _executionContext).Run(_executionContext));
}
public TransporterExpressionContainerDTO(TransporterExpressionContainer transporterContainer)
{
_transporterContainer = transporterContainer;
_transporterContainer.PropertyChanged += raisePropertyChange;
}
protected override void Context()
{
_repository = A.Fake <ITransporterContainerTemplateRepository>();
_eventPublisher = A.Fake <IEventPublisher>();
_transportDirectionRepository = A.Fake <ITransportDirectionRepository>();
sut = new TransportContainerUpdater(_repository, _eventPublisher);
_fractionExpressedApical = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameters.FRACTION_EXPRESSED_APICAL);
_fractionExpressedApicalMucosa = DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(CoreConstants.Parameters.FRACTION_EXPRESSED_APICAL);
_fractionExpressedApicalBone = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameters.FRACTION_EXPRESSED_APICAL);
//Indicates that this parameter should not be visible to the user and therefore remains unchanged
_fractionExpressedApicalBone.Visible = false;
_individual = A.Fake <ISimulationSubject>();
_individual.Species.Name = _species;
_transporter = new IndividualTransporter {
TransportType = TransportType.Efflux, Name = "toto"
};
var organism = new Organism();
var mucosa = new Container().WithName(CoreConstants.Compartment.MUCOSA).WithParentContainer(organism);
var liver = new Container().WithName(CoreConstants.Organ.LIVER).WithParentContainer(organism);
var liverCell = new Container().WithName(CoreConstants.Compartment.INTRACELLULAR).WithParentContainer(liver);
var kidney = new Container().WithName(CoreConstants.Organ.KIDNEY).WithParentContainer(organism);
var kidneyCell = new Container().WithName(CoreConstants.Compartment.INTRACELLULAR).WithParentContainer(kidney);
var bone = new Container().WithName(CoreConstants.Organ.BONE).WithParentContainer(organism);
var boneInterstitial = new Container().WithName(CoreConstants.Compartment.INTERSTITIAL).WithParentContainer(bone);
_transporterWithTemplate = new TransporterExpressionContainer {
TransportDirection = TransportDirectionId.InfluxInterstitialToIntracellular
}
.WithParentContainer(liverCell);
_transporterWithoutTemplate = new TransporterExpressionContainer
{
TransportDirection = TransportDirectionId.EffluxIntracellularToInterstitial
}
.WithParentContainer(kidneyCell);
_transporterInMucosa = new TransporterExpressionContainer {
TransportDirection = TransportDirectionId.InfluxInterstitialToIntracellular
}
.WithParentContainer(mucosa);
_transporterInBone = new TransporterExpressionContainer {
TransportDirection = TransportDirectionId.InfluxInterstitialToIntracellular
}
.WithParentContainer(boneInterstitial);
_transporterInMucosa.Add(_fractionExpressedApicalMucosa);
_transporterWithoutTemplate.Add(_fractionExpressedApical);
_transporterInBone.Add(_fractionExpressedApicalBone);
A.CallTo(() => _individual.AllMoleculeContainersFor <TransporterExpressionContainer>(_transporter))
.Returns(new[] { _transporterWithTemplate, _transporterWithoutTemplate, _transporterInMucosa, _transporterInBone });
_transporterContainerTemplate = new TransporterContainerTemplate {
TransportType = TransportType.Influx
};
_allTransporterTemplates.Add(_transporterContainerTemplate);
A.CallTo(() => _repository.HasTransporterTemplateFor(_species, _transporter.Name)).Returns(true);
A.CallTo(() => _repository.TransportTypeFor(_species, _transporter.Name)).Returns(TransportType.Influx);
A.CallTo(() => _repository.TransportersFor(_species, liver.Name, _transporter.Name)).Returns(_allTransporterTemplates);
A.CallTo(() => _repository.TransportersFor(_species, kidney.Name, _transporter.Name)).Returns(new List <TransporterContainerTemplate>());
}
private void addContainerExpression(TransporterExpressionDTO proteinExpressionDTO, IndividualTransporter transporter, TransporterExpressionContainer transporterExpressionContainer)
{
var expressionDTO = new TransporterExpressionContainerDTO(transporterExpressionContainer)
{
MoleculeName = transporter.Name, ContainerName = transporterExpressionContainer.Name
};
_expressionContainerDTOUpdater.UpdateProperties(expressionDTO, transporterExpressionContainer);
proteinExpressionDTO.AddProteinExpression(expressionDTO);
}
public ICommand SetMembraneLocationFor(TransporterExpressionContainer transporterContainer, TransportType transportType, MembraneLocation membraneLocation)
{
return(new SetMembraneTypeCommand(transporterContainer, transportType, membraneLocation, _executionContext).Run(_executionContext));
}
private IEnumerable <IContainer> allContainersForTransporter(Organism organism, IndividualTransporter transporter, IEnumerable <IContainer> allContainers, TransporterExpressionContainer expressionContainer)
{
if (expressionContainer.IsSurrogate())
{
return(allCompartmentsOfNames(allContainers, expressionContainer.Name));
}
return(compartmentFor(organism, expressionContainer, expressionContainer.CompartmentName));
}
