public override void GlobalContext()
{
base.GlobalContext();
_transporterContainerTemplateRepository = IoC.Resolve <ITransporterContainerTemplateRepository>();
var allTransporters = _transporterContainerTemplateRepository.TransportersFor(_individual.Species.Name, CoreConstants.Organ.Brain);
var influxBBB = allTransporters.Where(x => x.MembraneLocation == MembraneLocation.BloodBrainBarrier)
.FirstOrDefault(x => x.TransportType == TransportType.Influx);
_transporter = _transporterFactory.CreateFor(_individual).DowncastTo <IndividualTransporter>().WithName("TRANS");
var transportContainer = _transporter.ExpressionContainer(CoreConstants.Organ.Brain).DowncastTo <TransporterExpressionContainer>();
transportContainer.UpdatePropertiesFrom(influxBBB);
_individual.AddMolecule(_transporter);
_transportProcess = _cloneManager.Clone(_compoundProcessRepository.ProcessByName(CoreConstantsForSpecs.Process.ACTIVE_TRANSPORT_SPECIFIC_MM)
.DowncastTo <PartialProcess>());
_transportProcess.Name = "My Transport Process";
_compound.AddProcess(_transportProcess);
_simulation = DomainFactoryForSpecs.CreateModelLessSimulationWith(_individual, _compound, _protocol)
.DowncastTo <IndividualSimulation>();
_simulation.CompoundPropertiesList.First()
.Processes
.TransportAndExcretionSelection
.AddPartialProcessSelection(new EnzymaticProcessSelection {
CompoundName = _compound.Name, ProcessName = _transportProcess.Name, MoleculeName = _transporter.Name
});
DomainFactoryForSpecs.AddModelToSimulation(_simulation);
}
public IndividualTransporterDTO MapFrom(IndividualTransporter transporter, ISimulationSubject simulationSubject)
{
var dto = new IndividualTransporterDTO(transporter);
UpdateExpressionParameters(dto, simulationSubject);
return(dto);
}
private void updateTransporterParameterValues(IndividualTransporter transporter)
{
foreach (var relativeExpressionContainer in _expressionContainersRetriever.AllContainersFor(_spatialStructure, transporter))
{
setParameterValuesForStandardContainer(transporter, relativeExpressionContainer);
}
}
public void SetDefaultSettingsForTransporter(IndividualTransporter transporter, string species, string transporterName)
{
transporter.TransportType = _transporterContainerTemplateRepository.TransportTypeFor(species, transporterName);
foreach (var transporterContainer in transporter.AllExpressionsContainers())
{
//there is a db template
var tranporterTemplate = _transporterContainerTemplateRepository.TransportersFor(species, transporterContainer.Name, transporterName).FirstOrDefault();
if (tranporterTemplate != null)
{
transporterContainer.UpdatePropertiesFrom(tranporterTemplate);
}
else
{
UpdateTransporterFromTemplate(transporterContainer, species, MembraneLocationToUse(transporterContainer, transporter.TransportType), transporter.TransportType);
}
}
if (_transporterContainerTemplateRepository.HasTransporterTemplateFor(species, transporterName))
{
return;
}
//No template was found for the given name. Raise event warning
_eventPublisher.PublishEvent(new NoTranporterTemplateAvailableEvent(transporter));
}
public override void GlobalContext()
{
base.GlobalContext();
_transporter = _transporterFactory.CreateFor(_individual, "TRANS", TransportType.Efflux).DowncastTo <IndividualTransporter>();
var transportContainer = _individual.AllMoleculeContainersFor <TransporterExpressionContainer>(_transporter)
.First(x => x.LogicalContainer.IsNamed(CoreConstants.Organ.BRAIN));
transportContainer.TransportDirection = TransportDirectionId.InfluxBrainPlasmaToInterstitial;
_individual.AddMolecule(_transporter);
_transportProcess = _cloneManager.Clone(_compoundProcessRepository.ProcessByName(CoreConstantsForSpecs.Process.ACTIVE_TRANSPORT_SPECIFIC_MM)
.DowncastTo <PartialProcess>());
_transportProcess.Name = "My Transport Process";
_compound.AddProcess(_transportProcess);
_simulation = DomainFactoryForSpecs.CreateModelLessSimulationWith(_individual, _compound, _protocol)
.DowncastTo <IndividualSimulation>();
_simulation.CompoundPropertiesList.First()
.Processes
.TransportAndExcretionSelection
.AddPartialProcessSelection(new EnzymaticProcessSelection
{
CompoundName = _compound.Name, ProcessName = _transportProcess.Name, MoleculeName = _transporter.Name
});
DomainFactoryForSpecs.AddModelToSimulation(_simulation);
}
public void ActivateMolecule(IndividualMolecule molecule)
{
_transporter = molecule.DowncastTo <IndividualTransporter>();
_view.HideWarning();
_view.BindTo(_transporterExpressionDTOMapper.MapFrom(_transporter));
_moleculePropertiesPresenter.Edit(molecule, SimulationSubject.DowncastTo <TSimulationSubject>());
}
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
});
}
protected override void Context()
{
base.Context();
_transporter = new IndividualTransporter {TransportType = TransportType.Efflux, Name = "aa"};
A.CallTo(() => _repository.HasTransporterTemplateFor(_species, _transporterName)).Returns(false);
A.CallTo(() => _repository.TransportTypeFor(_species, _transporterName)).Returns(TransportType.Efflux);
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_moleculeMapper = A.Fake <MoleculeMapper>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_individualFactory = A.Fake <IIndividualFactory>();
_originDataMapper = A.Fake <OriginDataMapper>();
sut = new IndividualMapper(_parameterMapper, _moleculeMapper, _originDataMapper, _individualFactory);
_individual = DomainHelperForSpecs.CreateIndividual();
_individual.Name = "Ind";
_individual.Description = "Model Description";
_parameterLiver = _individual.EntityAt <IParameter>(Constants.ORGANISM, CoreConstants.Organ.Liver, "PLiver");
_parameterKidney = _individual.EntityAt <IParameter>(Constants.ORGANISM, CoreConstants.Organ.Kidney, "PKidney");
_parameterLiver.ValueDiffersFromDefault().ShouldBeFalse();
_parameterKidney.ValueDiffersFromDefault().ShouldBeFalse();
_parameterKidney.Value = 40;
_parameterKidney.ValueDiffersFromDefault().ShouldBeTrue();
_enzyme = new IndividualEnzyme
{
Name = "Enz",
};
_individual.AddMolecule(_enzyme);
_transporter = new IndividualTransporter
{
Name = "Trans",
};
_individual.AddMolecule(_transporter);
_enzymeSnapshot = new Molecule {
Type = QuantityType.Enzyme
};
_transporterSnapshot = new Molecule {
Type = QuantityType.Transporter
};
A.CallTo(() => _moleculeMapper.MapToSnapshot(_enzyme)).Returns(_enzymeSnapshot);
A.CallTo(() => _moleculeMapper.MapToSnapshot(_transporter)).Returns(_transporterSnapshot);
_originDataSnapshot = new OriginData();
A.CallTo(() => _originDataMapper.MapToSnapshot(_individual.OriginData)).Returns(_originDataSnapshot);
_localizedParameterKidney = new LocalizedParameter {
Path = "Organism|Kidney|PKidney"
};
A.CallTo(() => _parameterMapper.LocalizedParametersFrom(A <IEnumerable <IParameter> > .That.Contains(_parameterKidney))).Returns(new[] { _localizedParameterKidney });
return(_completed);
}
public TransporterExpressionDTO MapFrom(IndividualTransporter transporter)
{
var transporterExpressionDTO = new TransporterExpressionDTO(transporter);
foreach (var transporterExpressionContainer in transporter.GetChildren <ITransporterExpressionContainer>())
{
addContainerExpression(transporterExpressionDTO, transporter, transporterExpressionContainer);
}
return(transporterExpressionDTO);
}
public TransporterExpressionDTO MapFrom(IndividualTransporter transporter)
{
var transporterExpressionDTO = new TransporterExpressionDTO(transporter);
foreach (var transporterExpressionContainer in transporter.AllExpressionsContainers())
{
addContainerExpression(transporterExpressionDTO, transporter, transporterExpressionContainer);
}
return(transporterExpressionDTO);
}
public SetTransportTypeCommand(IndividualTransporter individualTransporter, TransportType transportType, IExecutionContext context)
{
_expressionProfile = context.BuildingBlockContaining(individualTransporter).DowncastTo <ExpressionProfile>();
_individualTransporter = individualTransporter;
_transportType = transportType;
BuildingBlockId = _expressionProfile.Id;
_transporterId = _individualTransporter.Id;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildingBlockPropertiesInCommand(this, _expressionProfile);
}
public SetTransportTypeInAllContainerCommand(IndividualTransporter individualTransporter, TransportType transportType, IExecutionContext context)
{
_individualTransporter = individualTransporter;
_individual = context.BuildingBlockContaining(individualTransporter).DowncastTo <Individual>();
NewTransportType = transportType;
OldTransportType = _individualTransporter.TransportType;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
Description = PKSimConstants.Command.SetTransportTypeCommandDescription(_individualTransporter.Name, OldTransportType.ToString(), NewTransportType.ToString());
context.UpdateBuildingBlockPropertiesInCommand(this, _individual);
}
public SetTransportTypeInTransporterCommand(IndividualTransporter individualTransporter, TransportType transportType, IExecutionContext context)
{
var individual = context.BuildingBlockContaining(individualTransporter).DowncastTo <Individual>();
_individualTransporter = individualTransporter;
_transportType = transportType;
BuildingBlockId = individual.Id;
_transporterId = _individualTransporter.Id;
ObjectType = PKSimConstants.ObjectTypes.Transporter;
CommandType = PKSimConstants.Command.CommandTypeEdit;
context.UpdateBuildinBlockPropertiesInCommand(this, individual);
}
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);
}
private void updateTransporterTagsFor(IndividualTransporter transporter, ITransportBuilder transporterBuilder, string simulationProcessName)
{
//if one organ was specified already, no need to create the list of not tags!
var allOrgans = transporter.AllOrgansWhereProcessTakesPlace(simulationProcessName).ToList();
var allMatchTags = transporterBuilder.SourceCriteria.OfType <MatchTagCondition>()
.Select(x => x.Tag);
if (allMatchTags.Intersect(allOrgans).Any())
{
return;
}
foreach (var organName in transporter.AllOrgansWhereProcessDoesNotTakePlace(simulationProcessName))
{
transporterBuilder.SourceCriteria.Add(new NotMatchTagCondition(organName));
}
}
public override void GlobalContext()
{
base.GlobalContext();
_individual = DomainFactoryForSpecs.CreateStandardIndividual();
_moleculeExpressionTask = IoC.Resolve <IMoleculeExpressionTask <Individual> >();
_ontogenyRepository = IoC.Resolve <IOntogenyRepository>();
_expressionProfileForEnzyme = DomainFactoryForSpecs.CreateExpressionProfile <IndividualEnzyme>();
_moleculeExpressionTask.AddExpressionProfile(_individual, _expressionProfileForEnzyme);
_individualEnzyme = _individual.MoleculeByName <IndividualEnzyme>(_expressionProfileForEnzyme.MoleculeName);
_expressionProfileEnzyme = _expressionProfileForEnzyme.Molecule.DowncastTo <IndividualEnzyme>();
_expressionProfileForTransporter = DomainFactoryForSpecs.CreateExpressionProfile <IndividualTransporter>(moleculeName: "TRANS");
_moleculeExpressionTask.AddExpressionProfile(_individual, _expressionProfileForTransporter);
_individualTransporter = _individual.MoleculeByName <IndividualTransporter>(_expressionProfileForTransporter.MoleculeName);
_expressionProfileTransporter = _expressionProfileForTransporter.Molecule.DowncastTo <IndividualTransporter>();
}
private IReadOnlyCollection <InducedProcess> allInducedProcessesFor(IndividualTransporter transporter, Individual individual)
{
var inducedProcessCache = new Cache <string, InducedProcess>(x => x.Name, x => null);
var allTransporterContainers = individual.AllMoleculeContainersFor <TransporterExpressionContainer>(transporter)
.Where(x => x.TransportDirection != TransportDirectionId.None).ToList();
//Global containers surrogate do not have a logical container associated
var allOrganNames = new HashSet <string>(allTransporterContainers.Select(x => x.LogicalContainerName).Where(x => !string.IsNullOrEmpty(x)));
foreach (var transporterContainer in allTransporterContainers)
{
//Logical containerName is empty for surrogate containers
var logicalContainer = transporterContainer.LogicalContainerName;
var allTransportTemplates = _transportTemplateRepository.All()
.Where(x => x.TransportDirection == transporterContainer.TransportDirection);
//a logical container is defined. We are dealing with a localized transporter
if (!string.IsNullOrEmpty(logicalContainer))
{
//For apical transport for Lumen => Mucosa, the compartment is the name of our mapping
allTransportTemplates = allTransportTemplates
.Where(x => (x.SourceOrgan == logicalContainer || x.SourceCompartment == logicalContainer));
}
foreach (var transportTemplate in allTransportTemplates)
{
var inducedProcess = inducedProcessCache[transportTemplate.ProcessName];
if (inducedProcess == null)
{
inducedProcess = new InducedProcess {
Name = transportTemplate.ProcessName
};
inducedProcess.AddOrgansToExclude(allOrganNames);
inducedProcessCache.Add(inducedProcess);
}
// For lumen transport. The source organ or target organ is in fact defined as a compartment
inducedProcess.AddSourceOrgan(transportTemplate.SourceOrgan.IsLumen() ? transportTemplate.SourceCompartment : transportTemplate.SourceOrgan);
inducedProcess.AddTargetOrgan(transportTemplate.TargetOrgan.IsLumen() ? transportTemplate.TargetCompartment : transportTemplate.TargetOrgan);
}
}
return(inducedProcessCache);
}
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 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);
}
public override void Execute(IExecutionContext context)
{
var transportContainerUpdater = context.Resolve <ITransportContainerUpdater>();
Add(new SetTransportTypeInTransporterCommand(_individualTransporter, NewTransportType, context));
//Check if a template is available for the given container. If yes, we're good to go and can create a change transporter type command
//we need to retrieve the process name for the given MembraneTupe/Process Type combo
foreach (var transporterContainer in _individualTransporter.AllExpressionsContainers())
{
var membraneLocationToUse = transportContainerUpdater.MembraneLocationToUse(transporterContainer, NewTransportType);
//change transport type
Add(new SetTransportTypeCommand(transporterContainer, OldTransportType, NewTransportType, membraneLocationToUse, context));
}
//now execute all commands
base.Execute(context);
//clear references
_individualTransporter = null;
_individual = null;
}
protected override void Context()
{
_view = A.Fake <IIndividualTransporterExpressionsView>();
_parameterTask = A.Fake <IEditParameterPresenterTask>();
_moleculeExpressionTask = A.Fake <IMoleculeExpressionTask <Individual> >();
_transporterMapper = A.Fake <IIndividualTransporterToTransporterExpressionDTOMapper>();
_moleculePropertiesPresenter = A.Fake <IIndividualMoleculePropertiesPresenter <Individual> >();
_transporterExpressionParametersPresenter = A.Fake <ITransporterExpressionParametersPresenter>();
sut = new IndividualTransporterExpressionsPresenter <Individual>(
_view, _parameterTask, _moleculeExpressionTask, _transporterMapper, _moleculePropertiesPresenter,
_transporterExpressionParametersPresenter);
_commandCollector = new PKSimMacroCommand();
sut.InitializeWith(_commandCollector);
_transporter = new IndividualTransporter();
_simulationSubject = new Individual();
_transporterDTO = new IndividualTransporterDTO(_transporter);
sut.SimulationSubject = _simulationSubject;
A.CallTo(() => _transporterMapper.MapFrom(_transporter, _simulationSubject)).Returns(_transporterDTO);
}
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);
_individualTransporter = context.Get <IndividualTransporter>(_transporterId);
}
protected override void ClearReferences()
{
_individualTransporter = null;
}
public ICommand SetTransporterTypeFor(IndividualTransporter transporter, TransportType transportType)
{
return(new SetTransportTypeInAllContainerCommand(transporter, transportType, _executionContext).Run(_executionContext));
}
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 NoTranporterTemplateAvailableEvent(IndividualTransporter transporter)
{
Transporter = transporter;
}
protected override async Task Because()
{
_newTransporter = await sut.MapToModel(_snapshot, _individual) as IndividualTransporter;
}
protected override Task Context()
{
_parameterMapper = A.Fake <ParameterMapper>();
_expressionContainerMapper = A.Fake <ExpressionContainerMapper>();
_executionContext = A.Fake <IExecutionContext>();
_individualMoleculeFactoryResolver = A.Fake <IIndividualMoleculeFactoryResolver>();
_ontogenyMapper = A.Fake <OntogenyMapper>();
_ontogenyTask = A.Fake <IOntogenyTask <Individual> >();
_individualMoleculeParametersTask = A.Fake <IMoleculeParameterTask>();
sut = new MoleculeMapper(_parameterMapper, _expressionContainerMapper,
_ontogenyMapper, _individualMoleculeFactoryResolver, _executionContext, _ontogenyTask, _individualMoleculeParametersTask);
_ontogeny = new DatabaseOntogeny
{
Name = "Ontogeny"
};
_enzyme = new IndividualEnzyme
{
Name = "Enzyme",
Description = "Help",
Ontogeny = _ontogeny,
};
_transporter = new IndividualTransporter
{
Name = "Transporter",
Description = "Help"
};
_otherProtein = new IndividualOtherProtein
{
Name = "OtherProtein",
Description = "Help"
};
_enzymeGlobalParameter = DomainHelperForSpecs.ConstantParameterWithValue(5, isDefault: true).WithName(CoreConstants.Parameters.HALF_LIFE_LIVER);
_enzymeGlobalParameterSnapshot = new Parameter();
A.CallTo(() => _parameterMapper.MapToSnapshot(_enzymeGlobalParameter)).Returns(_enzymeGlobalParameterSnapshot);
_expressionContainer1 = new MoleculeExpressionContainer {
Name = "Exp Container1"
};
_expressionContainer2 = new MoleculeExpressionContainer {
Name = "Exp Container2"
};
_enzyme.AddChildren(_expressionContainer1, _expressionContainer2, _enzymeGlobalParameter);
_relativeExpressionParameter1 = DomainHelperForSpecs.ConstantParameterWithValue(0.5).WithName(CoreConstants.Parameters.REL_EXP);
_relativeExpressionParameterNorm1 = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameters.REL_EXP_NORM);
_expressionContainer1.Add(_relativeExpressionParameter1);
_expressionContainer1.Add(_relativeExpressionParameterNorm1);
_relativeExpressionParameterNotSet = DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(CoreConstants.Parameters.REL_EXP);
_relativeExpressionParameterNotSetNorm = DomainHelperForSpecs.ConstantParameterWithValue(0).WithName(CoreConstants.Parameters.REL_EXP_NORM);
_expressionContainer2.Add(_relativeExpressionParameterNotSet);
_expressionContainer2.Add(_relativeExpressionParameterNotSetNorm);
_relativeExpressionContainerSnapshot1 = new ExpressionContainer();
_relativeExpressionContainerSnapshot2 = new ExpressionContainer();
A.CallTo(() => _expressionContainerMapper.MapToSnapshot(_expressionContainer1)).Returns(_relativeExpressionContainerSnapshot1);
A.CallTo(() => _expressionContainerMapper.MapToSnapshot(_expressionContainer2)).Returns(_relativeExpressionContainerSnapshot2);
_snapshotOntogeny = new Snapshots.Ontogeny();
A.CallTo(() => _ontogenyMapper.MapToSnapshot(_ontogeny)).Returns(_snapshotOntogeny);
_individual = new Individual();
return(_completed);
}
