protected override void Context()
{
base.Context();
_displayName = "tutu";
_expressionContainer = A.Fake <IMoleculeExpressionContainer>().WithName("tralal");
A.CallTo(() => _representationInfoRepository.DisplayNameFor(_expressionContainer)).Returns(_displayName);
}
protected override void Context()
{
base.Context();
_enzyme = A.Fake <IndividualEnzyme>();
A.CallTo(() => _enzyme.Rules).Returns(A.Fake <IBusinessRuleSet>());
_enzyme.Name = "CYP";
_container1 = new MoleculeExpressionContainer();
_container2 = new MoleculeExpressionContainer();
A.CallTo(() => _enzyme.GetChildren <IMoleculeExpressionContainer>()).Returns(new[] { _container1, _container2 });
}
private IEnumerable <IContainer> compartmentFor(Organism organism, IMoleculeExpressionContainer expressionContainer, string defaultCompartment)
{
var usedCompartment = expressionContainer.IsLumen ? expressionContainer.ContainerName : defaultCompartment;
var compartment = expressionContainer.CompartmentPath(usedCompartment).Resolve <IContainer>(organism);
if (compartment == null)
{
return(Enumerable.Empty <IContainer>());
}
return(new[] { compartment });
}
protected override void Context()
{
_individual = new Individual();
_individual.OriginData = new OriginData();
_individual.OriginData.Species = new Species().WithName("Human");
_ontogeny = new DatabaseOntogeny {
Name = "toto"
};
_molecule = new IndividualEnzyme {
Name = "CYP3A4"
};
_executionContext = A.Fake <IExecutionContext>();
_proteinExpressionPresenter = A.Fake <IProteinExpressionsPresenter>();
_simpleMoleculePresenter = A.Fake <ISimpleMoleculePresenter>();
_querySettingsMapper = A.Fake <IMoleculeToQueryExpressionSettingsMapper>();
_applicationController = A.Fake <IApplicationController>();
_individualMoleculeFactoryResolver = A.Fake <IIndividualMoleculeFactoryResolver>();
_transportContainerUpdater = A.Fake <ITransportContainerUpdater>();
_containerTask = A.Fake <IContainerTask>();
_moleculeParameterRepository = A.Fake <IMoleculeParameterRepository>();
_proteinExpressionDbPathManager = A.Fake <IProteinExpressionsDatabasePathManager>();
A.CallTo(() => _applicationController.Start <IProteinExpressionsPresenter>()).Returns(_proteinExpressionPresenter);
A.CallTo(() => _applicationController.Start <ISimpleMoleculePresenter>()).Returns(_simpleMoleculePresenter);
_ontogenyRepository = A.Fake <IOntogenyRepository>();
var proteinFactory = A.Fake <IIndividualMoleculeFactory>();
_moleculeContainer1 = new MoleculeExpressionContainer().WithName("C1");
_moleculeContainer1.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(CoreConstants.Parameter.RelExp));
_moleculeContainer1.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameter.RelExpNorm));
_moleculeContainer2 = new MoleculeExpressionContainer().WithName("C2");
_moleculeContainer2.Add(DomainHelperForSpecs.ConstantParameterWithValue(5).WithName(CoreConstants.Parameter.RelExp));
_moleculeContainer2.Add(DomainHelperForSpecs.ConstantParameterWithValue(1).WithName(CoreConstants.Parameter.RelExpNorm));
A.CallTo(() => _individualMoleculeFactoryResolver.FactoryFor <IndividualProtein>()).Returns(proteinFactory);
A.CallTo(() => proteinFactory.CreateFor(_individual)).Returns(_molecule);
_molecule.Add(_moleculeContainer1);
_molecule.Add(_moleculeContainer2);
_molecule.Add(DomainHelperForSpecs.ConstantParameterWithValue(10).WithName(CoreConstants.Parameter.REFERENCE_CONCENTRATION));
_molecule.Add(DomainHelperForSpecs.ConstantParameterWithValue(20).WithName(CoreConstants.Parameter.HALF_LIFE_LIVER));
_molecule.Add(DomainHelperForSpecs.ConstantParameterWithValue(30).WithName(CoreConstants.Parameter.HALF_LIFE_INTESTINE));
A.CallTo(() => _ontogenyRepository.AllFor(_individual.Species.Name)).Returns(new[] { _ontogeny, new DatabaseOntogeny {
Name = "tralala"
}, });
A.CallTo(() => _executionContext.Resolve <IOntogenyRepository>()).Returns(_ontogenyRepository);
_subjectExpressionTask = new IndividualExpressionTask(_executionContext);
_ontogenyTask = A.Fake <IOntogenyTask <Individual> >();
sut = new MoleculeExpressionTask <Individual>(_applicationController, _executionContext,
_individualMoleculeFactoryResolver, _querySettingsMapper,
_containerTask, _proteinExpressionDbPathManager,
_ontogenyRepository, _transportContainerUpdater, _moleculeParameterRepository, _subjectExpressionTask, _ontogenyTask);
}
protected override void Context()
{
_expressionContainer = new MoleculeExpressionContainer().WithName("tralal");
_expressionContainer.Add(A.Fake <IParameter>().WithName(CoreConstants.Parameter.RelExp));
_expressionContainer.Add(A.Fake <IParameter>().WithName(CoreConstants.Parameter.RelExpNorm));
_anotherContainer = new MoleculeExpressionContainer().WithName("AnotherContainer");
sut = new IndividualEnzyme();
_referenceConcentration = A.Fake <IParameter>().WithName(CoreConstants.Parameter.REFERENCE_CONCENTRATION);
sut.Add(_referenceConcentration);
sut.Add(_expressionContainer);
sut.Add(_anotherContainer);
}
protected override void Context()
{
base.Context();
_protein = A.Fake <IndividualProtein>();
_protein.QueryConfiguration = "toto";
_exp1 = A.Fake <IMoleculeExpressionContainer>().WithName("exp1");
_exp2 = A.Fake <IMoleculeExpressionContainer>().WithName("exp2");
_expInfo1 = A.Fake <ExpressionContainerInfo>();
_expInfo2 = A.Fake <ExpressionContainerInfo>();
A.CallTo(() => _protein.AllExpressionsContainers()).Returns(new[] { _exp1, _exp2 });
_proteinContent = 10;
A.CallTo(() => _protein.ReferenceConcentration).Returns(DomainHelperForSpecs.ConstantParameterWithValue(_proteinContent));
A.CallTo(() => _expressionContainerMapper.MapFrom(_exp1)).Returns(_expInfo1);
A.CallTo(() => _expressionContainerMapper.MapFrom(_exp2)).Returns(_expInfo2);
}
public void UpdateProperties(ExpressionContainerDTO expressionDTO, IMoleculeExpressionContainer expressionContainer)
{
var group = _groupRepository.GroupByName(expressionContainer.GroupName);
var groupInfo = _representationInfoRepository.InfoFor(RepresentationObjectType.GROUP, expressionContainer.GroupName);
var containerInfo = _representationInfoRepository.InfoFor(RepresentationObjectType.CONTAINER, expressionContainer.ContainerName);
expressionDTO.GroupingPathDTO = groupInfo.ToPathElement();
expressionDTO.ContainerPathDTO = containerInfo.ToPathElement();
expressionDTO.Sequence = group.Sequence;
expressionDTO.RelativeExpressionParameter =
_parameterMapper.MapFrom(expressionContainer.RelativeExpressionParameter, expressionDTO,
x => x.RelativeExpression, x => x.RelativeExpressionParameter);
expressionDTO.RelativeExpressionNormParameter =
_parameterMapper.MapFrom(expressionContainer.RelativeExpressionNormParameter, expressionDTO,
x => x.RelativeExpressionNorm, x => x.RelativeExpressionNormParameter);
}
public ExpressionContainerInfo MapFrom(IMoleculeExpressionContainer moleculeExpressionContainer)
{
return(new ExpressionContainerInfo(moleculeExpressionContainer.Name,
_representationInfoRepository.DisplayNameFor(moleculeExpressionContainer),
moleculeExpressionContainer.RelativeExpression));
}
private void updateReferenceToIndividualParametersForSurrogateContainer(Individual individual, IndividualMolecule molecule, IMoleculeExpressionContainer expressionContainer, IContainer globalMoleculeContainer)
{
string relExpName;
if (expressionContainer.IsBloodCell())
{
relExpName = CoreConstants.Parameter.REL_EXP_BLOOD_CELL;
}
else if (expressionContainer.IsPlasma())
{
relExpName = CoreConstants.Parameter.REL_EXP_PLASMA;
}
else if (expressionContainer.IsVascularEndothelium())
{
relExpName = CoreConstants.Parameter.REL_EXP_VASC_ENDO;
}
else
{
return;
}
var relExpNormName = CoreConstants.Parameter.NormParameterFor(relExpName);
updateFromIndividualParameter(globalMoleculeContainer.Parameter(relExpName), expressionContainer.RelativeExpressionParameter, individual, molecule);
updateFromIndividualParameter(globalMoleculeContainer.Parameter(relExpNormName), expressionContainer.RelativeExpressionNormParameter, individual, molecule);
}
private void updateReferenceToIndividualParametersForStandardContainer(Individual individual, IndividualMolecule molecule, IMoleculeExpressionContainer expressionContainer, IList <IContainer> allOrganismContainers, PathCache <IMoleculeAmount> moleculeAmountPath)
{
var allContainers = _expressionContainersRetriever.AllContainersFor(individual.Organism, allOrganismContainers, molecule, expressionContainer);
foreach (var container in allContainers)
{
var amount = amountFor(container, molecule, moleculeAmountPath);
if (amount == null)
{
continue;
}
updateFromIndividualParameter(amount.Parameter(CoreConstants.Parameter.REL_EXP), expressionContainer.RelativeExpressionParameter, individual, molecule);
updateFromIndividualParameter(amount.Parameter(CoreConstants.Parameter.REL_EXP_NORM), expressionContainer.RelativeExpressionNormParameter, individual, molecule);
}
}
private void addContainerExpression(ProteinExpressionDTO proteinExpressionDTO, IndividualProtein protein, IMoleculeExpressionContainer moleculeExpressionContainer)
{
var expressionDTO = new ExpressionContainerDTO {
MoleculeName = protein.Name, ContainerName = moleculeExpressionContainer.Name
};
_expressionContainerDTOUpdater.UpdateProperties(expressionDTO, moleculeExpressionContainer);
proteinExpressionDTO.AddProteinExpression(expressionDTO);
}
private IEnumerable <IContainer> allContainersFor(Organism organism, IndividualMolecule molecule, IEnumerable <IContainer> allContainers, IMoleculeExpressionContainer expressionContainer)
{
if (molecule.MoleculeType == QuantityType.Transporter)
{
return(allContainersForTransporter(organism, molecule.DowncastTo <IndividualTransporter>(), allContainers, expressionContainer.DowncastTo <ITransporterExpressionContainer>()));
}
var protein = molecule.DowncastTo <IndividualProtein>();
//plasma always generated
if (expressionContainer.IsPlasma())
{
return(allPlasmaCompartmentsOf(allContainers));
}
switch (protein.TissueLocation)
{
case TissueLocation.ExtracellularMembrane:
if (expressionContainer.IsBloodCell())
{
return(allPlasmaCompartmentsOf(allContainers));
}
if (expressionContainer.IsVascularEndothelium())
{
if (protein.MembraneLocation == MembraneLocation.Apical)
{
return(allPlasmaCompartmentsOf(allContainers));
}
return(allInterstitialCompartmentsOf(allContainers));
}
return(compartmentFor(organism, expressionContainer, CoreConstants.Compartment.Interstitial));
case TissueLocation.Intracellular:
if (expressionContainer.IsBloodCell())
{
return(allBloodCellsCompartmentsOf(allContainers));
}
if (expressionContainer.IsVascularEndothelium())
{
if (protein.IntracellularVascularEndoLocation == IntracellularVascularEndoLocation.Endosomal)
{
return(allEndosomeCompartmentsOf(allContainers));
}
return(allInterstitialCompartmentsOf(allContainers));
}
return(compartmentFor(organism, expressionContainer, CoreConstants.Compartment.Intracellular));
case TissueLocation.Interstitial:
if (expressionContainer.IsBloodCell())
{
return(allBloodCellsCompartmentsOf(allContainers));
}
if (expressionContainer.IsVascularEndothelium())
{
return(allInterstitialCompartmentsOf(allContainers));
}
return(compartmentFor(organism, expressionContainer, CoreConstants.Compartment.Interstitial));
default:
throw new ArgumentOutOfRangeException();
}
}
public IEnumerable <IContainer> AllContainersFor(Organism organism, IEnumerable <IContainer> allOrganismContainers, IndividualMolecule molecule, IMoleculeExpressionContainer expressionContainer)
{
return(allContainersFor(organism, molecule, allOrganismContainers, expressionContainer));
}
